/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {
  numDefine100,
  numDefine101,
  numDefine103,
  numDefine140,
  numDefine110,
  numDefine104,
  numDefine28,
  numDefine2,
  numDefine13,
  numDefine19,
  numDefine18,
  numDefine3,
  numDefine16,
  numDefine5,
  numDefine6,
  numDefine7,
  numDefine8,
  numDefine139,
  numDefine141,
  numDefine159,
  numDefine164,
  numDefine165,
  numDefine173,
  numDefineFloat265,
  numDefine29,
  numDefine20,
  numDefine14,
  numDefine72,
  numDefine73,
  numDefine74,
  numDefine75,
  numDefine76,
  numDefine77,
  numDefine78,
  numDefine79,
  numDefine80,
  numDefine81,
  numDefine82,
  numDefine83,
  numDefine84,
  numDefine85,
  numDefine86,
  numDefine87,
  numDefine88,
  numDefine90,
  numDefine92,
  numDefine96,
  numDefine30,
  numDefine21,
  numDefine31,
  numDefine22,
  numDefine32,
  numDefine23,
  numDefine33,
  numDefine10,
  numDefine9,
  numDefine4,
  numDefine15,
  numDefine11,
  numDefine48,
  numDefineNeg2,
  numDefine46,
  numDefineNeg8,
  numDefine56,
  numDefine64,
  numDefine58,
  numDefineNeg16,
  numDefine27,
  numDefine17,
  numDefine12,
  numDefine255,
  numDefineNeg24,
  numDefine54,
  numDefineNeg4,
  numDefine24,
  numDefineNeg40,
  numDefineNeg6,
  numDefineNeg12,
  numDefineNeg3,
  numDefine40,
  numDefine47,
  numDefine36,
  numDefine69,
  numDefine61,
  numDefine50,
  numDefine25,
  numDefine67,
  numDefine26,
  numDefine63,
  numDefine38,
  numDefine42,
  numDefine71,
  numDefine39,
  numDefine45,
  numDefine34,
  numDefine43,
  numDefine44,
  numDefine182,
  numDefine49,
  numDefine68,
  numDefine65,
  numDefine41,
  numDefine124,
  numDefine66,
  numDefine57,
  numDefine52,
  numDefine51,
  numDefine35,
  numDefine37,
  numDefine70,
  numDefine120,
  numDefine53,
  numDefine1024,
  numDefine60,
  numDefineNeg7,
  numDefineNeg5,
  numDefineNeg48,
  numDefineNeg184,
  numDefineNeg136,
  numDefineNeg102,
  numDefineNeg144,
  numDefine62,
  numDefine167,
  numDefineFloat05,
  numDefineNeg10,
  numDefineNeg112,
  numDefineNeg32,
  numDefineNeg21,
  numDefineNeg80,
  numDefineNeg20,
  numDefineNeg64,
  numDefineNeg23,
  numDefineNeg22,
  numDefineFloat4044,
  numDefineNeg120,
  numDefineFloat9165,
  numDefineNeg49440,
  numDefineNeg160,
  numDefineNeg65,
  numDefine280,
  numDefineNeg96,
  numDefineNeg25,
  numDefineNeg168,
  numDefineNeg152,
  numDefineNeg38,
  numDefine55,
  numDefine59,
  numDefine240,
  numDefine246,
  numDefineNeg176,
  numDefineNeg18,
  numDefineNeg1216,
  numDefineNeg304,
  numDefineNeg260,
  numDefineNeg280,
  numDefineNeg240,
  numDefineNeg816,
  numDefineNeg188,
  numDefineNeg172,
  numDefineNeg156,
  numDefineNeg92,
  numDefineNeg76,
  numDefineNeg60,
  numDefineNeg11,
  numDefineNeg56,
  numDefineNeg100,
  numDefineNeg88,
  numDefine49440,
  numDefineNeg42,
  numDefine279,
  numDefine277,
  numDefineNeg187,
  numDefineNeg179,
  numDefineNeg178,
  numDefineNeg177,
  numDefineNeg248,
  numDefineNeg186,
  numDefineNeg181,
  numDefineNeg182,
  numDefineNeg62,
  numDefineNeg180,
  numDefineNeg183,
  numDefineNeg195,
  numDefineNeg194,
  numDefineNeg191,
  numDefineNeg192,
  numDefineNeg189,
  numDefineNeg185,
  numDefineNeg196,
  numDefineNeg193,
  numDefineNeg190,
  numDefineNeg197,
  numDefineFloat1257,
  numDefineNeg66,
  numDefineNeg296,
  numDefineNeg74,
  numDefine177,
  numDefineNeg592,
  numDefineNeg52,
  numDefine278,
  numDefine204,
  numDefineNeg72,
  numDefineNeg14,
  numDefineFloat064,
  numDefineNeg104,
  numDefine276,
  numDefineFloat742,
  numDefineNeg400,
  numDefineNeg84,
  numDefineNeg232,
  numDefineNeg68,
  numDefineNeg28,
  numDefineNeg608,
  numDefineNeg800,
  numDefineNeg216,
  numDefineNeg440,
  numDefineNeg164,
  numDefineNeg26,
  numDefineNeg840,
  numDefineNeg210,
  numDefineNeg70,
  numDefineNeg58,
  numDefineNeg54,
  numDefineNeg78,
  numDefineNeg760,
  numDefineNeg776,
  numDefineNeg428,
  numDefineNeg63,
  numDefineNeg67,
  numDefineNeg69,
  numDefineNeg71,
  numDefineNeg73,
  numDefineNeg75,
  numDefineNeg77,
  numDefineNeg61,
  numDefineNeg99,
  numDefineNeg98,
  numDefineNeg97,
  numDefineNeg82,
  numDefineNeg79,
  numDefineNeg81,
  numDefineNeg86,
  numDefineNeg83,
  numDefineNeg85,
  numDefineNeg87,
  numDefineNeg93,
  numDefineNeg89,
  numDefineNeg94,
  numDefineNeg90,
  numDefineNeg95,
  numDefineNeg91,
  numDefineNeg101,
  numDefineNeg103,
  numDefineNeg105,
  numDefineNeg13,
  numDefine356,
  numDefineNeg9,
  numDefineNeg15,
  numDefineNeg17,
  numDefineNeg19,
  numDefineNeg1240,
  numDefineNeg664,
  numDefineNeg166,
  numDefineNeg1200,
  numDefineNeg868,
  numDefine1120,
  numDefine1124,
  numDefineNeg169,
  numDefineNeg171,
  numDefineNeg170,
  numDefineNeg174,
  numDefineNeg175,
  numDefineNeg173,
  numDefineFloat366,
  numDefineFloat183,
  numDefineNeg155,
  numDefineNeg157,
  numDefineNeg163,
  numDefineNeg158,
  numDefineNeg159,
  numDefineNeg162,
  numDefineNeg161,
  numDefineNeg165,
  numDefineNeg167,
  numDefineNeg616,
  numDefineNeg154,
  numDefineNeg27,
  numDefineNeg29,
  numDefine228,
  numDefine210,
  numDefine209,
  numDefine208,
  numDefine83646,
  numDefine41822,
  numDefineNeg30,
  numDefineNeg31,
  numDefine65533,
  numDefineFloat028,
  numDefineFloat002,
  numDefine97152,
  numDefineFloat026,
  numDefineFloat013,
  numDefineNegFloat013,
  numDefineFloat448,
  numDefine130,
  numDefine134,
  numDefine125,
  numDefine168,
  numDefine271,
  numDefine325,
  numDefine53216,
  numDefine199,
  numDefine190,
  numDefine309,
  numDefine191,
  numDefine319,
  numDefineNeg88609,
  numDefineNeg30432,
  numDefine95039,
  numDefine58986,
  numDefine44395,
  numDefine67991,
  numDefine53121,
  numDefine12625,
  numDefine56916,
  numDefine55635,
  numDefineNeg39253
} from './mandreel-part1/Class/DevNumber';

import {
  cosf,
  free,
  uint,
  assertNew,
  sqrtf,
  mallocNew,
  zdlPv,
  functionTable,
  sinf,
  llvmReadDouble,
  llvmMoveDouble,
  zn20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi,
  znk14btQuantizedBvh8quantizeEPtRK9btVector3i,
  znk14btQuantizedBvh9serializeEPvjb,
  z15btTransformAabbRK9btVector3S1FRK11btTransformRSS5,
  zn14btQuantizedBvh9buildTreeEii,
  zn14btQuantizedBvhD2Ev,
  zn28btCompoundCollisionAlgorithm26preallocateChildAlgorithmsEP17btCollisionObjectS1,
  znk14btQuantizedBvh26reportAabbOverlappingNodexEP21btNodeOverlapCallbackRK9btVector3S4
} from './commonFile';
import { commonVariable, heapClassInst } from './mandreel-part1/Class/CommonClassFile';
import {
  gNumAlignedAllocs,
  gNumAlignedFree,
  memcpy,
  twoEStr10,
  twoEStr10306,
  twoEStr109,
  twoEStr1100,
  twoEStr1110,
  twoEStr1129,
  twoEStr115,
  twoEStr128,
  twoEStr1350,
  twoEStr160,
  twoEStr173,
  twoEStr181,
  twoEStr18314,
  twoEStr19315,
  twoEStr194,
  twoEStr200,
  twoEStr20316,
  twoEStr2149,
  twoEStr2175,
  twoEStr219,
  twoEStr3112,
  twoEStr3150,
  twoEStr3222,
  twoEStr3352,
  twoEStr342,
  twoEStr3437,
  twoEStr349,
  twoEStr4119,
  twoEStr4198,
  twoEStr4438,
  twoEStr483,
  twoEStr5120,
  twoEStr5152,
  twoEStr5186,
  twoEStr5223,
  twoEStr5354,
  twoEStr59,
  twoEStr6187,
  twoEStr6199,
  twoEStr6224,
  twoEStr6232,
  twoEStr6249,
  twoEStr6355,
  twoEStr685,
  twoEStr7188,
  twoEStr7250,
  twoEStr7331,
  twoEStr7356,
  twoEStr8189,
  twoEStr8357,
  twoEStr9358,
  twoEStr99,
  zgvzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions,
  ztv12btConvexCast,
  ztv13btConvexShape,
  ztv13btSphereShape,
  ztv14btConcaveShape,
  ztv14btOptimizedBvh,
  ztv15btGjkConvexCast,
  ztv15btTriangleShape,
  ztv16btEmptyAlgorithm,
  ztv16btManifoldResult,
  ztv17btConvexHullShape,
  ztv17btGjkPairDetector,
  ztv18btTriangleCallback,
  ztv20btCollisionAlgorithm,
  ztv22btBvhTriangleMeshShape,
  ztv22btSubsimplexConvexCast,
  ztv22SphereTriangleDetector,
  ztv23btConvexConvexAlgorithm,
  ztv24btConvexTriangleCallback,
  ztv24btPerturbedContactResult,
  ztv25btSimulationIslandManager,
  ztv26btBoxBoxCollisionAlgorithm,
  ztv28btCompoundCollisionAlgorithm,
  ztv30btActivatingCollisionAlgorithm,
  ztv31btConvexPlaneCollisionAlgorithm,
  ztv31btDefaultCollisionConfiguration,
  ztv31btInternalTriangleIndexCallback,
  ztv32btSphereSphereCollisionAlgorithm,
  ztv33btConvexConcaveCollisionAlgorithm,
  ztv34btSphereTriangleCollisionAlgorithm,
  ztvn12btConvexCast10CastResultE,
  ztvn16btEmptyAlgorithm10CreateFuncE,
  ztvn23btConvexConvexAlgorithm10CreateFuncE,
  ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE,
  ztvn28btCompoundCollisionAlgorithm10CreateFuncE,
  ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE,
  ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE,
  ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE,
  ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE,
  ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE,
  ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE,
  ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback,
  ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback,
  ztvzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback,
  ztvzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback,
  zn33btCollisionObjectS1RK,
  ztvznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback,
  zzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions
} from './commonFile';
import {
  zn15btGjkConvexCast16calcTimeCast10Cast,
  zn17btGjkPairDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb,
  zn19btTriangleMeshShape15recalcLocalAabbEv,
  zn20btPersistentManifold20refreshContactPointsERK11btTransformS2,
  zn22btSubsimplexConvexCastTimeTransform
} from './mandreelFile5';

function memset(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp];
  if (!(r0 === 0)) {
    r2 = heapClassInst.heap32[fp + 1];
    r3 = r1;
    repeat3: while (true) {
      r0 = (r0 + -1) | 0;
      r4 = (r3 + 1) | 0;
      heapClassInst.heap8[r3] = r2;
      r3 = r4;
      if (r0 !== 0) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  commonVariable.rg0 = r1;
  return;
}

function zn28btCompoundCollisionAlgorithmD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv28btCompoundCollisionAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine3];
  if (!(r1 < 1)) {
    r3 = 0;
    repeat3: while (true) {
      r4 = heapClassInst.heap32[r2 + numDefine5];
      r5 = r3 << numDefine2;
      r4 = (r4 + r5) | 0;
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      if (!(r4 === 0)) {
        r6 = r4 >> numDefine2;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6];
        heapClassInst.heap32[g0] = r4;
        functionTable[r6 >> numDefine2](i7);
        r4 = heapClassInst.heap32[r2 + 1];
        r6 = r4 >> numDefine2;
        r7 = heapClassInst.heap32[r2 + numDefine5];
        r5 = (r7 + r5) | 0;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r5 = r5 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine13];
        r5 = heapClassInst.heap32[r5];
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = r5;
        functionTable[r6 >> numDefine2](i7);
      }
      r3 = (r3 + 1) | 0;
      if (r1 !== r3) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r1 = heapClassInst.heap32[r2 + numDefine5];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine24];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine5] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine24] = r1;
  heapClassInst.heap32[r2 + numDefine5] = 0;
  r1 = ztv30btActivatingCollisionAlgorithm;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn28btCompoundCollisionAlgorithmD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv28btCompoundCollisionAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine3];
  if (!(r1 < 1)) {
    r3 = 0;
    repeat3: while (true) {
      r4 = heapClassInst.heap32[r2 + numDefine5];
      r5 = r3 << numDefine2;
      r4 = (r4 + r5) | 0;
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      if (!(r4 === 0)) {
        r6 = r4 >> numDefine2;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6];
        heapClassInst.heap32[g0] = r4;
        functionTable[r6 >> numDefine2](i7);
        r4 = heapClassInst.heap32[r2 + 1];
        r6 = r4 >> numDefine2;
        r7 = heapClassInst.heap32[r2 + numDefine5];
        r5 = (r7 + r5) | 0;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r5 = r5 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine13];
        r5 = heapClassInst.heap32[r5];
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = r5;
        functionTable[r6 >> numDefine2](i7);
      }
      r3 = (r3 + 1) | 0;
      if (r1 !== r3) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r1 = heapClassInst.heap32[r2 + numDefine5];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine24];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine5] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine24] = r1;
  heapClassInst.heap32[r2 + numDefine5] = 0;
  r0 = ztv30btActivatingCollisionAlgorithm;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  r0 = (r0 + numDefine8) | 0;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2] = r0;
  return;
}

function znk21btConvexInternalShape15getLocalScalingEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = (r0 + numDefine12) | 0;
  commonVariable.rg0 = r0;
  return;
}

function zn21btConvexInternalShape9setMarginEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine11] = heapClassInst.heap32[fp + 1];
  return;
}

function znk21btConvexInternalShape9getMarginEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine11];
  commonVariable.fg0 = f0;
  return;
}

function znk21btConvexInternalShape28calculateSerializeBufferSizeEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine52;
  commonVariable.rg0 = r0;
  return;
}

function znk15btTriangleShape14getNumVerticesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine3;
  commonVariable.rg0 = r0;
  return;
}

function znk15btTriangleShape9getVertexEiR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r0 = r0 << numDefine4;
  r2 = heapClassInst.heap32[fp + numDefine2];
  r0 = (r1 + r0) | 0;
  r1 = r2 >> numDefine2;
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine13];
  heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine14];
  heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine15];
  heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine16];
  return;
}

function znk15btTriangleShape11getNumEdgesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine3;
  commonVariable.rg0 = r0;
  return;
}

function znk15btTriangleShape7getEdgeEiR9btVector3S1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine24];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  functionTable[r2 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine24];
  r2 = (r3 + 1) | 0;
  r2 = r2 % numDefine3 | 0;
  r3 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  functionTable[r1 >> numDefine2](i7);
  return;
}

function znk15btTriangleShape7getAabbERK11btTransformR9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine18];
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  heapClassInst.heap32[g0 + numDefine3] = r4;
  functionTable[r1 >> numDefine2](i7);
  return;
}

function znk15btTriangleShape37localGetSupportingVertexWithoutMarginERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  f0 = heapClassInst.heapFloat[r2 + numDefine13];
  f1 = heapClassInst.heapFloat[r1];
  f2 = heapClassInst.heapFloat[r2 + numDefine17];
  f3 = heapClassInst.heapFloat[r2 + numDefine21];
  f4 = heapClassInst.heapFloat[r2 + numDefine14];
  f5 = heapClassInst.heapFloat[r1 + 1];
  f6 = heapClassInst.heapFloat[r2 + numDefine18];
  f7 = heapClassInst.heapFloat[r2 + numDefine22];
  f0 = f1 * f0;
  f4 = f5 * f4;
  f8 = heapClassInst.heapFloat[r2 + numDefine15];
  f9 = heapClassInst.heapFloat[r1 + numDefine2];
  f10 = heapClassInst.heapFloat[r2 + numDefine19];
  f11 = heapClassInst.heapFloat[r2 + numDefine23];
  f2 = f1 * f2;
  f6 = f5 * f6;
  f1 = f1 * f3;
  f3 = f5 * f7;
  f0 = f0 + f4;
  f4 = f9 * f8;
  f2 = f2 + f6;
  f5 = f9 * f10;
  f1 = f1 + f3;
  f3 = f9 * f11;
  f0 = f0 + f4;
  f2 = f2 + f5;
  r1 = heapClassInst.heap32[fp];
  f1 = f1 + f3;
  if (f0 >= f2) {
    r2 = numDefine2;
    r3 = 0;
    r2 = f0 < f1 ? r2 : r3;
  } else {
    r2 = numDefine2;
    r3 = 1;
    r2 = f2 < f1 ? r2 : r3;
  }
  r2 = r2 << numDefine4;
  r0 = (r0 + r2) | 0;
  r1 = r1 >> numDefine2;
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine13];
  heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine14];
  heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine15];
  heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine16];
  return;
}

function znk15btTriangleShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine3];
  if (!(r0 < 1)) {
    r1 = heapClassInst.heap32[fp];
    r2 = heapClassInst.heap32[fp + 1];
    r3 = heapClassInst.heap32[fp + numDefine2];
    r2 = (r2 + numDefine8) | 0;
    r3 = (r3 + numDefine12) | 0;
    repeat3: while (true) {
      r4 = r1 >> numDefine2;
      r5 = r2 >> numDefine2;
      f0 = heapClassInst.heapFloat[r4 + numDefine13];
      f1 = heapClassInst.heapFloat[r5 + numDefineNeg2];
      f2 = heapClassInst.heapFloat[r4 + numDefine17];
      f3 = heapClassInst.heapFloat[r4 + numDefine21];
      f4 = heapClassInst.heapFloat[r4 + numDefine14];
      f5 = heapClassInst.heapFloat[r5 + -1];
      f6 = heapClassInst.heapFloat[r4 + numDefine18];
      f7 = heapClassInst.heapFloat[r4 + numDefine22];
      f0 = f1 * f0;
      f4 = f5 * f4;
      f8 = heapClassInst.heapFloat[r4 + numDefine15];
      f9 = heapClassInst.heapFloat[r5];
      f10 = heapClassInst.heapFloat[r4 + numDefine19];
      f11 = heapClassInst.heapFloat[r4 + numDefine23];
      f2 = f1 * f2;
      f6 = f5 * f6;
      f1 = f1 * f3;
      f3 = f5 * f7;
      f0 = f0 + f4;
      f4 = f9 * f8;
      f2 = f2 + f6;
      f5 = f9 * f10;
      f1 = f1 + f3;
      f3 = f9 * f11;
      f0 = f0 + f4;
      f2 = f2 + f5;
      f1 = f1 + f3;
      if (f0 >= f2) {
        r4 = numDefine2;
        r5 = 0;
        r4 = f0 < f1 ? r4 : r5;
      } else {
        r4 = numDefine2;
        r5 = 1;
        r4 = f2 < f1 ? r4 : r5;
      }
      r4 = r4 << numDefine4;
      r4 = (r1 + r4) | 0;
      r5 = r3 >> numDefine2;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r5 + numDefineNeg3] = heapClassInst.heap32[r4 + numDefine13];
      heapClassInst.heap32[r5 + numDefineNeg2] = heapClassInst.heap32[r4 + numDefine14];
      r0 = (r0 + -1) | 0;
      r2 = (r2 + numDefine16) | 0;
      r3 = (r3 + numDefine16) | 0;
      heapClassInst.heap32[r5 + -1] = heapClassInst.heap32[r4 + numDefine15];
      heapClassInst.heap32[r5] = heapClassInst.heap32[r4 + numDefine16];
      if (r0 !== 0) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function znk15btTriangleShape8getPlaneER9btVector3S1I(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine28];
  r2 = heapClassInst.heap32[fp + numDefine3];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  heapClassInst.heap32[g0 + numDefine3] = r4;
  functionTable[r1 >> numDefine2](i7);
  return;
}

function znk15btTriangleShape12getNumPlanesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 1;
  commonVariable.rg0 = r0;
  return;
}

function znk15btTriangleShape7getNameEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr109;
  commonVariable.rg0 = r0;
  return;
}

function znk15btTriangleShape36getNumPreferredPenetrationDirectionsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine2;
  commonVariable.rg0 = r0;
  return;
}

function zn24btConvexTriangleCallbackD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv24btConvexTriangleCallback;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  r1 = heapClassInst.heap32[r0 + numDefine12];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine5];
  r3 = heapClassInst.heap32[r0 + numDefine16];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r3;
  functionTable[r2 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r0 + numDefine12];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  r3 = heapClassInst.heap32[r0 + numDefine16];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r3;
  r1 = ztv18btTriangleCallback;
  r1 = (r1 + numDefine8) | 0;
  functionTable[r2 >> numDefine2](i7);
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn24btConvexTriangleCallbackD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv24btConvexTriangleCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine12];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine5];
  r4 = heapClassInst.heap32[r2 + numDefine16];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r4;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine12];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine4];
  r4 = heapClassInst.heap32[r2 + numDefine16];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r4;
  r1 = ztv18btTriangleCallback;
  r1 = (r1 + numDefine8) | 0;
  functionTable[r3 >> numDefine2](i7);
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn24btConvexTriangleCallback15processTriangleEP9btVector3ii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg240;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine13];
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[r0 + numDefine12];
  r4 = heapClassInst.heap32[r0 + numDefine2];
  if (!(r1 === 0)) {
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine5];
    if (!(r1 === 0)) {
      r5 = r1 >> numDefine2;
      r5 = heapClassInst.heap32[r5];
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5 + numDefine12];
      heapClassInst.heap32[g0] = r1;
      functionTable[r5 >> numDefine2](i7);
      r1 = commonVariable.rg0 & 1;
      if (!(r1 === 0)) {
        r1 = sp + numDefineNeg112;
        r5 = r1 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg28] = numDefine53216;
        heapClassInst.heap32[r5 + 1] = numDefine53216;
        heapClassInst.heap32[r5 + numDefine2] = 0;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        r5 = heapClassInst.heap32[r0 + numDefine13];
        r5 = r5 >> numDefine2;
        r6 = r4 >> numDefine2;
        r7 = r2 >> numDefine2;
        r8 = heapClassInst.heap32[r5 + numDefine5];
        r8 = r8 >> numDefine2;
        f0 = heapClassInst.heapFloat[r7 + numDefine4];
        f1 = heapClassInst.heapFloat[r6 + 1];
        f2 = heapClassInst.heapFloat[r7 + numDefine5];
        f3 = heapClassInst.heapFloat[r6 + numDefine2];
        r8 = heapClassInst.heap32[r8];
        f4 = heapClassInst.heapFloat[r6 + numDefine5];
        f5 = heapClassInst.heapFloat[r6 + numDefine6];
        f1 = f1 * f0;
        f3 = f3 * f2;
        f6 = heapClassInst.heapFloat[r7 + numDefine6];
        f7 = heapClassInst.heapFloat[r6 + numDefine3];
        r8 = r8 >> numDefine2;
        f8 = heapClassInst.heapFloat[r6 + numDefine9];
        f9 = heapClassInst.heapFloat[r6 + numDefine10];
        f10 = heapClassInst.heapFloat[r6 + numDefine7];
        f4 = f4 * f0;
        f5 = f5 * f2;
        f1 = f1 + f3;
        f3 = f7 * f6;
        f7 = heapClassInst.heapFloat[r6 + numDefine11];
        r8 = heapClassInst.heap32[r8 + numDefine2];
        f0 = f8 * f0;
        f2 = f9 * f2;
        f4 = f4 + f5;
        f5 = f10 * f6;
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r6 + numDefine13];
        f8 = heapClassInst.heapFloat[r6 + numDefine15];
        f9 = heapClassInst.heapFloat[r6 + numDefine14];
        r9 = sp + numDefineNeg96;
        f4 = f4 + f5;
        f0 = f0 + f2;
        f2 = f7 * f6;
        f1 = f1 + f3;
        f0 = f0 + f2;
        r10 = r9 >> numDefine2;
        f2 = f4 + f9;
        heapClassInst.heapFloat[fp + numDefineNeg24] = f1;
        f0 = f0 + f8;
        heapClassInst.heapFloat[r10 + 1] = f2;
        heapClassInst.heapFloat[r10 + numDefine2] = f0;
        heapClassInst.heap32[r10 + numDefine3] = 0;
        f0 = heapClassInst.heapFloat[r7];
        f1 = heapClassInst.heapFloat[r6 + 1];
        f2 = heapClassInst.heapFloat[r7 + 1];
        f3 = heapClassInst.heapFloat[r6 + numDefine2];
        f4 = heapClassInst.heapFloat[r6 + numDefine5];
        f5 = heapClassInst.heapFloat[r6 + numDefine6];
        f1 = f1 * f0;
        f3 = f3 * f2;
        f6 = heapClassInst.heapFloat[r7 + numDefine2];
        f7 = heapClassInst.heapFloat[r6 + numDefine3];
        f8 = heapClassInst.heapFloat[r6 + numDefine9];
        f9 = heapClassInst.heapFloat[r6 + numDefine10];
        f10 = heapClassInst.heapFloat[r6 + numDefine7];
        f4 = f4 * f0;
        f5 = f5 * f2;
        f1 = f1 + f3;
        f3 = f7 * f6;
        f7 = heapClassInst.heapFloat[r6 + numDefine11];
        f0 = f8 * f0;
        f2 = f9 * f2;
        f4 = f4 + f5;
        f5 = f10 * f6;
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r6 + numDefine13];
        f8 = heapClassInst.heapFloat[r6 + numDefine15];
        f9 = heapClassInst.heapFloat[r6 + numDefine14];
        r10 = sp + numDefineNeg80;
        f4 = f4 + f5;
        f0 = f0 + f2;
        f2 = f7 * f6;
        f1 = f1 + f3;
        f0 = f0 + f2;
        r11 = r10 >> numDefine2;
        f2 = f4 + f9;
        heapClassInst.heapFloat[fp + numDefineNeg20] = f1;
        f0 = f0 + f8;
        heapClassInst.heapFloat[r11 + 1] = f2;
        heapClassInst.heapFloat[r11 + numDefine2] = f0;
        heapClassInst.heap32[r11 + numDefine3] = 0;
        r5 = heapClassInst.heap32[r5 + numDefine5];
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r10;
        heapClassInst.heap32[g0 + numDefine2] = r9;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        functionTable[r8 >> numDefine2](i7);
        r5 = heapClassInst.heap32[r0 + numDefine13];
        r5 = r5 >> numDefine2;
        r8 = heapClassInst.heap32[r5 + numDefine5];
        r8 = r8 >> numDefine2;
        f0 = heapClassInst.heapFloat[r7 + numDefine8];
        f1 = heapClassInst.heapFloat[r6 + 1];
        f2 = heapClassInst.heapFloat[r7 + numDefine9];
        f3 = heapClassInst.heapFloat[r6 + numDefine2];
        r8 = heapClassInst.heap32[r8];
        f4 = heapClassInst.heapFloat[r6 + numDefine5];
        f5 = heapClassInst.heapFloat[r6 + numDefine6];
        f1 = f1 * f0;
        f3 = f3 * f2;
        f6 = heapClassInst.heapFloat[r7 + numDefine10];
        f7 = heapClassInst.heapFloat[r6 + numDefine3];
        r8 = r8 >> numDefine2;
        f8 = heapClassInst.heapFloat[r6 + numDefine9];
        f9 = heapClassInst.heapFloat[r6 + numDefine10];
        f10 = heapClassInst.heapFloat[r6 + numDefine7];
        f4 = f4 * f0;
        f5 = f5 * f2;
        f1 = f1 + f3;
        f3 = f7 * f6;
        f7 = heapClassInst.heapFloat[r6 + numDefine11];
        r8 = heapClassInst.heap32[r8 + numDefine2];
        f0 = f8 * f0;
        f2 = f9 * f2;
        f4 = f4 + f5;
        f5 = f10 * f6;
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r6 + numDefine13];
        f8 = heapClassInst.heapFloat[r6 + numDefine15];
        f9 = heapClassInst.heapFloat[r6 + numDefine14];
        r9 = sp + numDefineNeg64;
        f4 = f4 + f5;
        f0 = f0 + f2;
        f2 = f7 * f6;
        f1 = f1 + f3;
        f0 = f0 + f2;
        r10 = r9 >> numDefine2;
        f2 = f4 + f9;
        heapClassInst.heapFloat[fp + numDefineNeg16] = f1;
        f0 = f0 + f8;
        heapClassInst.heapFloat[r10 + 1] = f2;
        heapClassInst.heapFloat[r10 + numDefine2] = f0;
        heapClassInst.heap32[r10 + numDefine3] = 0;
        f0 = heapClassInst.heapFloat[r7 + numDefine4];
        f1 = heapClassInst.heapFloat[r6 + 1];
        f2 = heapClassInst.heapFloat[r7 + numDefine5];
        f3 = heapClassInst.heapFloat[r6 + numDefine2];
        f4 = heapClassInst.heapFloat[r6 + numDefine5];
        f5 = heapClassInst.heapFloat[r6 + numDefine6];
        f1 = f1 * f0;
        f3 = f3 * f2;
        f6 = heapClassInst.heapFloat[r7 + numDefine6];
        f7 = heapClassInst.heapFloat[r6 + numDefine3];
        f8 = heapClassInst.heapFloat[r6 + numDefine9];
        f9 = heapClassInst.heapFloat[r6 + numDefine10];
        f10 = heapClassInst.heapFloat[r6 + numDefine7];
        f4 = f4 * f0;
        f5 = f5 * f2;
        f1 = f1 + f3;
        f3 = f7 * f6;
        f7 = heapClassInst.heapFloat[r6 + numDefine11];
        f0 = f8 * f0;
        f2 = f9 * f2;
        f4 = f4 + f5;
        f5 = f10 * f6;
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r6 + numDefine13];
        f8 = heapClassInst.heapFloat[r6 + numDefine15];
        f9 = heapClassInst.heapFloat[r6 + numDefine14];
        r10 = sp + numDefineNeg48;
        f4 = f4 + f5;
        f0 = f0 + f2;
        f2 = f7 * f6;
        f1 = f1 + f3;
        f0 = f0 + f2;
        r11 = r10 >> numDefine2;
        f2 = f4 + f9;
        heapClassInst.heapFloat[fp + numDefineNeg12] = f1;
        f0 = f0 + f8;
        heapClassInst.heapFloat[r11 + 1] = f2;
        heapClassInst.heapFloat[r11 + numDefine2] = f0;
        heapClassInst.heap32[r11 + numDefine3] = 0;
        r5 = heapClassInst.heap32[r5 + numDefine5];
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r10;
        heapClassInst.heap32[g0 + numDefine2] = r9;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        functionTable[r8 >> numDefine2](i7);
        r5 = heapClassInst.heap32[r0 + numDefine13];
        r5 = r5 >> numDefine2;
        r8 = heapClassInst.heap32[r5 + numDefine5];
        r8 = r8 >> numDefine2;
        f0 = heapClassInst.heapFloat[r7];
        f1 = heapClassInst.heapFloat[r6 + 1];
        f2 = heapClassInst.heapFloat[r7 + 1];
        f3 = heapClassInst.heapFloat[r6 + numDefine2];
        r8 = heapClassInst.heap32[r8];
        f4 = heapClassInst.heapFloat[r6 + numDefine5];
        f5 = heapClassInst.heapFloat[r6 + numDefine6];
        f1 = f1 * f0;
        f3 = f3 * f2;
        f6 = heapClassInst.heapFloat[r7 + numDefine2];
        f7 = heapClassInst.heapFloat[r6 + numDefine3];
        r8 = r8 >> numDefine2;
        f8 = heapClassInst.heapFloat[r6 + numDefine9];
        f9 = heapClassInst.heapFloat[r6 + numDefine10];
        f10 = heapClassInst.heapFloat[r6 + numDefine7];
        f4 = f4 * f0;
        f5 = f5 * f2;
        f1 = f1 + f3;
        f3 = f7 * f6;
        f7 = heapClassInst.heapFloat[r6 + numDefine11];
        r8 = heapClassInst.heap32[r8 + numDefine2];
        f0 = f8 * f0;
        f2 = f9 * f2;
        f4 = f4 + f5;
        f5 = f10 * f6;
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r6 + numDefine13];
        f8 = heapClassInst.heapFloat[r6 + numDefine15];
        f9 = heapClassInst.heapFloat[r6 + numDefine14];
        r9 = sp + numDefineNeg32;
        f4 = f4 + f5;
        f0 = f0 + f2;
        f2 = f7 * f6;
        f1 = f1 + f3;
        f0 = f0 + f2;
        r10 = r9 >> numDefine2;
        f2 = f4 + f9;
        heapClassInst.heapFloat[fp + numDefineNeg8] = f1;
        f0 = f0 + f8;
        heapClassInst.heapFloat[r10 + 1] = f2;
        heapClassInst.heapFloat[r10 + numDefine2] = f0;
        heapClassInst.heap32[r10 + numDefine3] = 0;
        f0 = heapClassInst.heapFloat[r7 + numDefine8];
        f1 = heapClassInst.heapFloat[r6 + 1];
        f2 = heapClassInst.heapFloat[r7 + numDefine9];
        f3 = heapClassInst.heapFloat[r6 + numDefine2];
        f4 = heapClassInst.heapFloat[r6 + numDefine5];
        f5 = heapClassInst.heapFloat[r6 + numDefine6];
        f1 = f1 * f0;
        f3 = f3 * f2;
        f6 = heapClassInst.heapFloat[r7 + numDefine10];
        f7 = heapClassInst.heapFloat[r6 + numDefine3];
        f8 = heapClassInst.heapFloat[r6 + numDefine9];
        f9 = heapClassInst.heapFloat[r6 + numDefine10];
        f10 = heapClassInst.heapFloat[r6 + numDefine7];
        f4 = f4 * f0;
        f5 = f5 * f2;
        f1 = f1 + f3;
        f3 = f7 * f6;
        f7 = heapClassInst.heapFloat[r6 + numDefine11];
        f0 = f8 * f0;
        f2 = f9 * f2;
        f4 = f4 + f5;
        f5 = f10 * f6;
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r6 + numDefine13];
        f8 = heapClassInst.heapFloat[r6 + numDefine15];
        f9 = heapClassInst.heapFloat[r6 + numDefine14];
        r6 = sp + numDefineNeg16;
        f4 = f4 + f5;
        f0 = f0 + f2;
        f2 = f7 * f6;
        f1 = f1 + f3;
        f0 = f0 + f2;
        r7 = r6 >> numDefine2;
        f2 = f4 + f9;
        heapClassInst.heapFloat[fp + numDefineNeg4] = f1;
        f0 = f0 + f8;
        heapClassInst.heapFloat[r7 + 1] = f2;
        heapClassInst.heapFloat[r7 + numDefine2] = f0;
        heapClassInst.heap32[r7 + numDefine3] = 0;
        r5 = heapClassInst.heap32[r5 + numDefine5];
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = r9;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        functionTable[r8 >> numDefine2](i7);
      }
    }
  }
  r1 = heapClassInst.heap32[r0 + 1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine48];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + 1];
  if (!(r1 > numDefine19)) {
    r1 = heapClassInst.heap32[fp + numDefine2];
    r5 = heapClassInst.heap32[fp + numDefine3];
    r6 = sp + numDefineNeg216;
    r7 = r6 >> numDefine2;
    heapClassInst.heap32[r7 + numDefine2] = 0;
    heapClassInst.heap32[r7 + numDefine3] = numDefine53216;
    heapClassInst.heap32[r7 + numDefine4] = numDefine53216;
    r8 = ztv15btTriangleShape;
    heapClassInst.heap32[r7 + numDefine5] = numDefine53216;
    r8 = (r8 + numDefine8) | 0;
    heapClassInst.heap32[r7 + numDefine6] = 0;
    heapClassInst.heap32[fp + numDefineNeg54] = r8;
    r2 = r2 >> numDefine2;
    heapClassInst.heap32[r7 + 1] = 1;
    heapClassInst.heap32[r7 + numDefine13] = heapClassInst.heap32[r2];
    heapClassInst.heap32[r7 + numDefine14] = heapClassInst.heap32[r2 + 1];
    heapClassInst.heap32[r7 + numDefine15] = heapClassInst.heap32[r2 + numDefine2];
    heapClassInst.heap32[r7 + numDefine16] = heapClassInst.heap32[r2 + numDefine3];
    heapClassInst.heap32[r7 + numDefine17] = heapClassInst.heap32[r2 + numDefine4];
    heapClassInst.heap32[r7 + numDefine18] = heapClassInst.heap32[r2 + numDefine5];
    heapClassInst.heap32[r7 + numDefine19] = heapClassInst.heap32[r2 + numDefine6];
    heapClassInst.heap32[r7 + numDefine20] = heapClassInst.heap32[r2 + numDefine7];
    heapClassInst.heap32[r7 + numDefine21] = heapClassInst.heap32[r2 + numDefine8];
    heapClassInst.heap32[r7 + numDefine22] = heapClassInst.heap32[r2 + numDefine9];
    heapClassInst.heap32[r7 + numDefine23] = heapClassInst.heap32[r2 + numDefine10];
    heapClassInst.heap32[r7 + numDefine24] = heapClassInst.heap32[r2 + numDefine11];
    r2 = r4 >> numDefine2;
    heapClassInst.heap32[r7 + numDefine11] = heapClassInst.heap32[r0 + numDefine14];
    r4 = heapClassInst.heap32[r2 + numDefine48];
    heapClassInst.heap32[r2 + numDefine48] = r6;
    r6 = r3 >> numDefine2;
    r7 = heapClassInst.heap32[r6];
    r7 = r7 >> numDefine2;
    r7 = heapClassInst.heap32[r7 + numDefine2];
    r8 = heapClassInst.heap32[r0 + numDefine16];
    r9 = heapClassInst.heap32[r0 + numDefine2];
    r10 = heapClassInst.heap32[r0 + 1];
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r10;
    heapClassInst.heap32[g0 + numDefine2] = r9;
    heapClassInst.heap32[g0 + numDefine3] = r8;
    functionTable[r7 >> numDefine2](i7);
    r7 = commonVariable.rg0;
    r8 = heapClassInst.heap32[r0 + numDefine11];
    r9 = r8 >> numDefine2;
    r10 = heapClassInst.heap32[r9];
    r9 = heapClassInst.heap32[r9 + numDefine34];
    r11 = heapClassInst.heap32[r0 + numDefine2];
    if (r9 !== r11) {
      r9 = r10 >> numDefine2;
      r9 = heapClassInst.heap32[r9 + numDefine3];
      heapClassInst.heap32[g0] = r8;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = r5;
      functionTable[r9 >> numDefine2](i7);
    } else {
      r10 = r10 >> numDefine2;
      r10 = heapClassInst.heap32[r10 + numDefine2];
      heapClassInst.heap32[g0] = r8;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = r5;
      functionTable[r10 >> numDefine2](i7);
    }
    r1 = r7 >> numDefine2;
    r5 = heapClassInst.heap32[r1];
    r5 = r5 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine2];
    r8 = heapClassInst.heap32[r0 + numDefine11];
    r9 = heapClassInst.heap32[r0 + numDefine13];
    r10 = heapClassInst.heap32[r0 + numDefine2];
    r0 = heapClassInst.heap32[r0 + 1];
    heapClassInst.heap32[g0] = r7;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r10;
    heapClassInst.heap32[g0 + numDefine3] = r9;
    heapClassInst.heap32[g0 + numDefine4] = r8;
    functionTable[r5 >> numDefine2](i7);
    r0 = heapClassInst.heap32[r1];
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0];
    heapClassInst.heap32[g0] = r7;
    functionTable[r0 >> numDefine2](i7);
    r0 = heapClassInst.heap32[r6];
    r0 = r0 >> numDefine2;
    r0 = heapClassInst.heap32[r0 + numDefine13];
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r7;
    functionTable[r0 >> numDefine2](i7);
    heapClassInst.heap32[r2 + numDefine48] = r4;
  }
  return;
}

function zn33btCollisionAlgorithm(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv18btTriangleCallback;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn33btConcaveCollision(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv18btTriangleCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn30btConvexConcave(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg800;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg64;
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
  heapClassInst.heap32[r1 + 1] = 0;
  heapClassInst.heap32[r1 + numDefine2] = 0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  heapClassInst.heap32[r1 + numDefine4] = 0;
  heapClassInst.heap32[r1 + numDefine5] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine6] = 0;
  heapClassInst.heap32[r1 + numDefine7] = 0;
  heapClassInst.heap32[r1 + numDefine8] = 0;
  heapClassInst.heap32[r1 + numDefine9] = 0;
  heapClassInst.heap32[r1 + numDefine10] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine11] = 0;
  heapClassInst.heap32[r1 + numDefine12] = 0;
  heapClassInst.heap32[r1 + numDefine13] = 0;
  r2 = ztvn12btConvexCast10CastResultE;
  heapClassInst.heap32[r1 + numDefine14] = 0;
  r3 = sp + numDefineNeg240;
  r2 = (r2 + numDefine8) | 0;
  heapClassInst.heap32[r1 + numDefine15] = 0;
  r1 = r3 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg60] = r2;
  r2 = heapClassInst.heap32[fp];
  heapClassInst.heap32[r1 + numDefine42] = 0;
  r4 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine43] = 0;
  r5 = sp + numDefineNeg296;
  heapClassInst.heap32[r1 + numDefine41] = heapClassInst.heap32[r4 + numDefine50];
  r6 = r5 >> numDefine2;
  f0 = heapClassInst.heapFloat[r4 + numDefine49];
  heapClassInst.heap32[r6 + numDefine2] = 0;
  heapClassInst.heap32[r6 + numDefine3] = numDefine53216;
  heapClassInst.heap32[r6 + numDefine4] = numDefine53216;
  r7 = ztv13btSphereShape;
  heapClassInst.heap32[r6 + numDefine5] = numDefine53216;
  r7 = (r7 + numDefine8) | 0;
  heapClassInst.heap32[r6 + numDefine6] = 0;
  heapClassInst.heap32[fp + numDefineNeg74] = r7;
  heapClassInst.heap32[r6 + 1] = numDefine8;
  r7 = sp + numDefineNeg400;
  heapClassInst.heapFloat[r6 + numDefine7] = f0;
  r8 = r7 >> numDefine2;
  heapClassInst.heapFloat[r6 + numDefine11] = f0;
  heapClassInst.heap32[r8 + numDefine2] = 0;
  heapClassInst.heap32[r8 + numDefine3] = numDefine53216;
  heapClassInst.heap32[r8 + numDefine4] = numDefine53216;
  heapClassInst.heap32[r8 + numDefine5] = numDefine53216;
  r6 = ztv15btTriangleShape;
  heapClassInst.heap32[r8 + numDefine6] = 0;
  r6 = (r6 + numDefine8) | 0;
  heapClassInst.heap32[r8 + numDefine11] = numDefine58986;
  r9 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[fp + numDefineNeg100] = r6;
  r6 = r9 >> numDefine2;
  heapClassInst.heap32[r8 + 1] = 1;
  heapClassInst.heap32[r8 + numDefine13] = heapClassInst.heap32[r6];
  heapClassInst.heap32[r8 + numDefine14] = heapClassInst.heap32[r6 + 1];
  heapClassInst.heap32[r8 + numDefine15] = heapClassInst.heap32[r6 + numDefine2];
  heapClassInst.heap32[r8 + numDefine16] = heapClassInst.heap32[r6 + numDefine3];
  heapClassInst.heap32[r8 + numDefine17] = heapClassInst.heap32[r6 + numDefine4];
  heapClassInst.heap32[r8 + numDefine18] = heapClassInst.heap32[r6 + numDefine5];
  heapClassInst.heap32[r8 + numDefine19] = heapClassInst.heap32[r6 + numDefine6];
  heapClassInst.heap32[r8 + numDefine20] = heapClassInst.heap32[r6 + numDefine7];
  heapClassInst.heap32[r8 + numDefine21] = heapClassInst.heap32[r6 + numDefine8];
  heapClassInst.heap32[r8 + numDefine22] = heapClassInst.heap32[r6 + numDefine9];
  r9 = sp + numDefineNeg760;
  heapClassInst.heap32[r8 + numDefine23] = heapClassInst.heap32[r6 + numDefine10];
  r10 = r9 >> numDefine2;
  heapClassInst.heap32[r8 + numDefine24] = heapClassInst.heap32[r6 + numDefine11];
  r6 = ztv22btSubsimplexConvexCast;
  r8 = 0;
  heapClassInst.heap32[r10 + numDefine77] = numDefine67991;
  r10 = sp + numDefineNeg776;
  r6 = (r6 + numDefine8) | 0;
  heapClassInst.heap8[sp + numDefineNeg428] = r8;
  r8 = r10 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg194] = r6;
  heapClassInst.heap32[r8 + 1] = r9;
  heapClassInst.heap32[r8 + numDefine2] = r5;
  heapClassInst.heap32[r8 + numDefine3] = r7;
  r5 = (r2 + numDefine4) | 0;
  r2 = (r2 + numDefine68) | 0;
  heapClassInst.heap32[g0] = r10;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r0;
  heapClassInst.heap32[g0 + numDefine4] = r0;
  heapClassInst.heap32[g0 + numDefine5] = r3;
  zn22btSubsimplexConvexCastTimeTransform(i7);
  r0 = commonVariable.rg0;
  if (!(r0 === 0)) {
    f0 = heapClassInst.heapFloat[r1 + numDefine41];
    f1 = heapClassInst.heapFloat[r4 + numDefine50];
    if (!(f1 <= f0)) {
      heapClassInst.heapFloat[r4 + numDefine50] = f0;
    }
  }
  return;
}

function zn15btTriangleShapeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn15btTriangleShapeD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  if (!(r0 === 0)) {
    r0 = gNumAlignedFree;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0];
    r1 = (r1 + 1) | 0;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r2 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}

function znk15btTriangleShape21calculateLocalInertiaEfR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr10;
  r1 = twoEStr3112;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = numDefine125;
  assertNew(i7);
}

function znk21btConvexInternalShape9serializeEPvP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine10];
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r4 = heapClassInst.heap32[r1];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine7];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  r5 = heapClassInst.heap32[fp + 1];
  functionTable[r4 >> numDefine2](i7);
  r4 = commonVariable.rg0;
  r5 = r5 >> numDefine2;
  heapClassInst.heap32[r5] = r4;
  if (!(r4 === 0)) {
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine12];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    functionTable[r1 >> numDefine2](i7);
  }
  r0 = r3 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + 1];
  heapClassInst.heap32[r5 + 1] = r1;
  heapClassInst.heap32[r5 + numDefine7] = heapClassInst.heap32[r0 + numDefine7];
  heapClassInst.heap32[r5 + numDefine8] = heapClassInst.heap32[r0 + numDefine8];
  heapClassInst.heap32[r5 + numDefine9] = heapClassInst.heap32[r0 + numDefine9];
  heapClassInst.heap32[r5 + numDefine10] = heapClassInst.heap32[r0 + numDefine10];
  heapClassInst.heap32[r5 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
  heapClassInst.heap32[r5 + numDefine4] = heapClassInst.heap32[r0 + numDefine4];
  heapClassInst.heap32[r5 + numDefine5] = heapClassInst.heap32[r0 + numDefine5];
  heapClassInst.heap32[r5 + numDefine6] = heapClassInst.heap32[r0 + numDefine6];
  heapClassInst.heap32[r5 + numDefine11] = heapClassInst.heap32[r0 + numDefine11];
  r0 = twoEStr1110;
  commonVariable.rg0 = r0;
  return;
}

function znk15btTriangleShape32getPreferredPenetrationDirectionEiR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine23];
  f1 = heapClassInst.heapFloat[r0 + numDefine15];
  f2 = heapClassInst.heapFloat[r0 + numDefine19];
  f3 = heapClassInst.heapFloat[r0 + numDefine22];
  f4 = heapClassInst.heapFloat[r0 + numDefine14];
  f5 = heapClassInst.heapFloat[r0 + numDefine18];
  f5 = f5 - f4;
  f0 = f0 - f1;
  f1 = f2 - f1;
  f2 = f3 - f4;
  f3 = heapClassInst.heapFloat[r0 + numDefine21];
  f4 = heapClassInst.heapFloat[r0 + numDefine13];
  f6 = heapClassInst.heapFloat[r0 + numDefine17];
  f3 = f3 - f4;
  f4 = f6 - f4;
  r0 = heapClassInst.heap32[fp + numDefine2];
  f6 = f5 * f0;
  f7 = f1 * f2;
  f6 = f6 - f7;
  f1 = f1 * f3;
  f0 = f4 * f0;
  r0 = r0 >> numDefine2;
  f0 = f1 - f0;
  heapClassInst.heapFloat[r0] = f6;
  f1 = f4 * f2;
  f2 = f5 * f3;
  f1 = f1 - f2;
  heapClassInst.heapFloat[r0 + 1] = f0;
  heapClassInst.heapFloat[r0 + numDefine2] = f1;
  f2 = f6 * f6;
  f0 = f0 * f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  f0 = f2 + f0;
  f1 = f1 * f1;
  f0 = f0 + f1;
  heapClassInst.heapFloat[g0] = f0;
  sqrtf(i7);
  f1 = 1;
  f0 = f1 / commonVariable.fg0;
  f1 = heapClassInst.heapFloat[r0];
  f1 = f1 * f0;
  heapClassInst.heapFloat[r0] = f1;
  f2 = heapClassInst.heapFloat[r0 + 1];
  f2 = f2 * f0;
  heapClassInst.heapFloat[r0 + 1] = f2;
  f3 = heapClassInst.heapFloat[r0 + numDefine2];
  f0 = f3 * f0;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  r1 = heapClassInst.heap32[fp + 1];
  if (!(r1 === 0)) {
    f1 = -f1;
    f2 = -f2;
    heapClassInst.heapFloat[r0] = f1;
    f0 = -f0;
    heapClassInst.heapFloat[r0 + 1] = f2;
    heapClassInst.heapFloat[r0 + numDefine2] = f0;
  }
  return;
}

function znk15btTriangleShape8isInsideERK9btVector3f(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r1 + numDefine19];
  f1 = heapClassInst.heapFloat[r1 + numDefine15];
  f2 = heapClassInst.heapFloat[r1 + numDefine23];
  f3 = heapClassInst.heapFloat[r1 + numDefine17];
  f4 = heapClassInst.heapFloat[r1 + numDefine13];
  f5 = heapClassInst.heapFloat[r1 + numDefine21];
  f6 = heapClassInst.heapFloat[r1 + numDefine22];
  f7 = heapClassInst.heapFloat[r1 + numDefine14];
  f8 = heapClassInst.heapFloat[r1 + numDefine18];
  f0 = f0 - f1;
  f6 = f6 - f7;
  f3 = f3 - f4;
  f1 = f2 - f1;
  f2 = f8 - f7;
  f4 = f5 - f4;
  f5 = f2 * f1;
  f7 = f0 * f6;
  f0 = f0 * f4;
  f1 = f3 * f1;
  f5 = f5 - f7;
  f0 = f0 - f1;
  f1 = f3 * f6;
  f2 = f2 * f4;
  f1 = f1 - f2;
  f2 = f5 * f5;
  f3 = f0 * f0;
  f2 = f2 + f3;
  f3 = f1 * f1;
  f2 = f2 + f3;
  heapClassInst.heapFloat[g0] = f2;
  sqrtf(i7);
  r2 = heapClassInst.heap32[fp + 1];
  f3 = 1;
  r2 = r2 >> numDefine2;
  f2 = f3 / commonVariable.fg0;
  f4 = f5 * f2;
  f5 = heapClassInst.heapFloat[r2];
  f6 = heapClassInst.heapFloat[r1 + numDefine13];
  f0 = f0 * f2;
  f7 = heapClassInst.heapFloat[r2 + 1];
  f8 = heapClassInst.heapFloat[r1 + numDefine14];
  f1 = f1 * f2;
  f2 = heapClassInst.heapFloat[r2 + numDefine2];
  f9 = heapClassInst.heapFloat[r1 + numDefine15];
  f5 = f5 * f4;
  f7 = f7 * f0;
  f6 = f6 * f4;
  f8 = f8 * f0;
  f5 = f5 + f7;
  f2 = f2 * f1;
  f6 = f6 + f8;
  f7 = f9 * f1;
  f8 = heapClassInst.heapFloat[fp + numDefine2];
  f2 = f5 + f2;
  f5 = f6 + f7;
  f2 = f2 - f5;
  f5 = -f8;
  repeat1: do {
    if (f2 < f5) {
      label = numDefine2;
    } else {
      if (f2 <= f8) {
        r3 = 0;
        repeat4: while (true) {
          if (r3 < numDefine3) {
            r4 = heapClassInst.heap32[r1];
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4 + numDefine23];
            r5 = sp + numDefineNeg32;
            r6 = sp + numDefineNeg16;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = r6;
            heapClassInst.heap32[g0 + numDefine3] = r5;
            functionTable[r4 >> numDefine2](i7);
            r4 = r5 >> numDefine2;
            r5 = r6 >> numDefine2;
            f2 = heapClassInst.heapFloat[r4 + numDefine2];
            f6 = heapClassInst.heapFloat[r5 + numDefine2];
            f7 = heapClassInst.heapFloat[r4 + 1];
            f8 = heapClassInst.heapFloat[r5 + 1];
            f9 = heapClassInst.heapFloat[fp + numDefineNeg8];
            f10 = heapClassInst.heapFloat[fp + numDefineNeg4];
            f2 = f2 - f6;
            f6 = f9 - f10;
            f7 = f7 - f8;
            f8 = f7 * f1;
            f9 = f2 * f0;
            f2 = f2 * f4;
            f10 = f6 * f1;
            f8 = f8 - f9;
            f2 = f2 - f10;
            f6 = f6 * f0;
            f7 = f7 * f4;
            f6 = f6 - f7;
            f7 = f8 * f8;
            f9 = f2 * f2;
            f7 = f7 + f9;
            f9 = f6 * f6;
            f7 = f7 + f9;
            heapClassInst.heapFloat[g0] = f7;
            sqrtf(i7);
            f7 = f3 / commonVariable.fg0;
            f9 = heapClassInst.heapFloat[r2];
            f8 = f8 * f7;
            f10 = heapClassInst.heapFloat[fp + numDefineNeg4];
            f11 = heapClassInst.heapFloat[r2 + 1];
            f2 = f2 * f7;
            f12 = heapClassInst.heapFloat[r5 + 1];
            f9 = f9 * f8;
            f11 = f11 * f2;
            f13 = heapClassInst.heapFloat[r2 + numDefine2];
            f6 = f6 * f7;
            f7 = heapClassInst.heapFloat[r5 + numDefine2];
            f8 = f10 * f8;
            f2 = f12 * f2;
            f9 = f9 + f11;
            f10 = f13 * f6;
            f2 = f8 + f2;
            f6 = f7 * f6;
            f7 = f9 + f10;
            f2 = f2 + f6;
            f2 = f7 - f2;
            if (f2 < f5) {
              label = numDefine2;
              break repeat1;
            } else {
              r3 = (r3 + 1) | 0;
            }
          } else {
            break repeat4;
          }
        }
        r0 = 1;
        label = numDefine8;
      } else {
        label = numDefine2;
      }
    }
  } while (false);
  if (label === numDefine2) {
    r0 = 0;
  }
  r0 = r0 & numDefine255;
  commonVariable.rg0 = r0;
  return;
}

function znk15btTriangleShape16getPlaneEquationEiR9btVector3S1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine23];
  f1 = heapClassInst.heapFloat[r0 + numDefine15];
  f2 = heapClassInst.heapFloat[r0 + numDefine19];
  f3 = heapClassInst.heapFloat[r0 + numDefine22];
  f4 = heapClassInst.heapFloat[r0 + numDefine14];
  f5 = heapClassInst.heapFloat[r0 + numDefine18];
  f5 = f5 - f4;
  f0 = f0 - f1;
  f1 = f2 - f1;
  f2 = f3 - f4;
  f3 = heapClassInst.heapFloat[r0 + numDefine21];
  f4 = heapClassInst.heapFloat[r0 + numDefine13];
  f6 = heapClassInst.heapFloat[r0 + numDefine17];
  f3 = f3 - f4;
  f4 = f6 - f4;
  r1 = heapClassInst.heap32[fp + numDefine2];
  f6 = f5 * f0;
  f7 = f1 * f2;
  f6 = f6 - f7;
  r1 = r1 >> numDefine2;
  f1 = f1 * f3;
  f0 = f4 * f0;
  f0 = f1 - f0;
  heapClassInst.heapFloat[r1] = f6;
  f1 = f4 * f2;
  f2 = f5 * f3;
  f1 = f1 - f2;
  heapClassInst.heapFloat[r1 + 1] = f0;
  heapClassInst.heapFloat[r1 + numDefine2] = f1;
  f2 = f6 * f6;
  f0 = f0 * f0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  f0 = f2 + f0;
  f1 = f1 * f1;
  f0 = f0 + f1;
  heapClassInst.heapFloat[g0] = f0;
  sqrtf(i7);
  f1 = 1;
  f0 = f1 / commonVariable.fg0;
  f1 = heapClassInst.heapFloat[r1];
  f1 = f1 * f0;
  heapClassInst.heapFloat[r1] = f1;
  f1 = heapClassInst.heapFloat[r1 + 1];
  f1 = f1 * f0;
  heapClassInst.heapFloat[r1 + 1] = f1;
  f1 = heapClassInst.heapFloat[r1 + numDefine2];
  r2 = heapClassInst.heap32[fp + numDefine3];
  f0 = f1 * f0;
  r2 = r2 >> numDefine2;
  heapClassInst.heapFloat[r1 + numDefine2] = f0;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r0 + numDefine13];
  heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r0 + numDefine14];
  heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + numDefine15];
  heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine16];
  return;
}

function zn33btConvexConcaveCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let f29: number = 0.0;
  let f30: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg440;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = heapClassInst.heapU8[r0 + numDefine8];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = r0 === 0 ? r1 : r2;
  r3 = r3 >> numDefine2;
  f0 = heapClassInst.heapFloat[r3 + numDefine30];
  f1 = heapClassInst.heapFloat[r3 + numDefine14];
  f2 = heapClassInst.heapFloat[r3 + numDefine29];
  f3 = heapClassInst.heapFloat[r3 + numDefine13];
  f4 = f2 - f3;
  f5 = f0 - f1;
  f6 = heapClassInst.heapFloat[r3 + numDefine31];
  f7 = heapClassInst.heapFloat[r3 + numDefine15];
  f8 = f6 - f7;
  f4 = f4 * f4;
  f5 = f5 * f5;
  f9 = heapClassInst.heapFloat[r3 + numDefine62];
  f4 = f4 + f5;
  f5 = f8 * f8;
  f8 = f9 * f9;
  f4 = f4 + f5;
  if (!(f8 > f4)) {
    r0 = r0 === 0 ? r2 : r1;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0 + numDefine48];
    r2 = r1 >> numDefine2;
    r4 = heapClassInst.heap32[r2 + 1];
    r4 = (r4 + numDefineNeg21) | 0;
    if (!(uint(r4) > uint(numDefine8))) {
      f4 = heapClassInst.heapFloat[r0 + numDefine13];
      f5 = heapClassInst.heapFloat[r0 + numDefine3];
      f8 = heapClassInst.heapFloat[r0 + numDefine2];
      f4 = -f4;
      f9 = heapClassInst.heapFloat[r0 + 1];
      f10 = heapClassInst.heapFloat[r0 + numDefine7];
      f11 = heapClassInst.heapFloat[r0 + numDefine6];
      f12 = heapClassInst.heapFloat[r0 + numDefine14];
      f13 = heapClassInst.heapFloat[r0 + numDefine5];
      f14 = heapClassInst.heapFloat[r3 + numDefine3];
      f15 = heapClassInst.heapFloat[r3 + numDefine7];
      f16 = heapClassInst.heapFloat[r3 + numDefine2];
      f17 = heapClassInst.heapFloat[r3 + numDefine6];
      f18 = heapClassInst.heapFloat[r3 + 1];
      f19 = heapClassInst.heapFloat[r3 + numDefine5];
      f20 = heapClassInst.heapFloat[r3 + numDefine19];
      heapClassInst.heapFloat[fp + numDefineNeg63] = f20;
      f21 = heapClassInst.heapFloat[r3 + numDefine23];
      f22 = heapClassInst.heapFloat[r3 + numDefine18];
      f23 = heapClassInst.heapFloat[r3 + numDefine22];
      f24 = heapClassInst.heapFloat[r3 + numDefine17];
      f25 = heapClassInst.heapFloat[r3 + numDefine21];
      f26 = f5 * f3;
      heapClassInst.heapFloat[fp + numDefineNeg65] = f26;
      f27 = f10 * f1;
      f28 = f8 * f3;
      heapClassInst.heapFloat[fp + numDefineNeg66] = f28;
      f29 = f11 * f1;
      f3 = f9 * f3;
      heapClassInst.heapFloat[fp + numDefineNeg64] = f3;
      f1 = f13 * f1;
      f30 = heapClassInst.heapFloat[r0 + numDefine11];
      f3 = heapClassInst.heapFloat[r0 + numDefine10];
      f20 = heapClassInst.heapFloat[r0 + numDefine15];
      f26 = heapClassInst.heapFloat[r0 + numDefine9];
      f28 = f5 * f2;
      heapClassInst.heapFloat[fp + numDefineNeg67] = f28;
      f28 = f10 * f0;
      heapClassInst.heapFloat[fp + numDefineNeg69] = f28;
      f28 = f5 * f4;
      heapClassInst.heapFloat[fp + numDefineNeg68] = f28;
      f28 = f10 * f12;
      heapClassInst.heapFloat[fp + numDefineNeg71] = f28;
      f28 = f8 * f2;
      heapClassInst.heapFloat[fp + numDefineNeg70] = f28;
      f28 = f11 * f0;
      heapClassInst.heapFloat[fp + numDefineNeg73] = f28;
      f28 = f8 * f4;
      heapClassInst.heapFloat[fp + numDefineNeg72] = f28;
      f28 = f11 * f12;
      heapClassInst.heapFloat[fp + numDefineNeg78] = f28;
      f2 = f9 * f2;
      heapClassInst.heapFloat[fp + numDefineNeg74] = f2;
      f0 = f13 * f0;
      heapClassInst.heapFloat[fp + numDefineNeg76] = f0;
      f4 = f9 * f4;
      heapClassInst.heapFloat[fp + numDefineNeg75] = f4;
      f12 = f13 * f12;
      heapClassInst.heapFloat[fp + numDefineNeg77] = f12;
      f0 = heapClassInst.heapFloat[r3 + numDefine11];
      f2 = heapClassInst.heapFloat[r3 + numDefine10];
      f4 = heapClassInst.heapFloat[r3 + numDefine9];
      f12 = heapClassInst.heapFloat[r3 + numDefine27];
      f28 = heapClassInst.heapFloat[r3 + numDefine26];
      heapClassInst.heapFloat[fp + numDefineNeg62] = f28;
      f28 = heapClassInst.heapFloat[r3 + numDefine25];
      heapClassInst.heapFloat[fp + numDefineNeg61] = f28;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg65];
      f27 = f28 + f27;
      heapClassInst.heapFloat[fp + numDefineNeg65] = f27;
      f27 = f30 * f7;
      heapClassInst.heapFloat[fp + numDefineNeg99] = f27;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg66];
      f28 = f28 + f29;
      heapClassInst.heapFloat[fp + numDefineNeg66] = f28;
      f29 = f3 * f7;
      heapClassInst.heapFloat[fp + numDefineNeg98] = f29;
      f27 = heapClassInst.heapFloat[fp + numDefineNeg64];
      f1 = f27 + f1;
      heapClassInst.heapFloat[fp + numDefineNeg80] = f1;
      f7 = f26 * f7;
      heapClassInst.heapFloat[fp + numDefineNeg97] = f7;
      f27 = f14 * f5;
      heapClassInst.heapFloat[fp + numDefineNeg64] = f27;
      f1 = f15 * f10;
      heapClassInst.heapFloat[fp + numDefineNeg82] = f1;
      f1 = f16 * f5;
      heapClassInst.heapFloat[fp + numDefineNeg79] = f1;
      f1 = f17 * f10;
      heapClassInst.heapFloat[fp + numDefineNeg84] = f1;
      f1 = f18 * f5;
      heapClassInst.heapFloat[fp + numDefineNeg81] = f1;
      f1 = f19 * f10;
      heapClassInst.heapFloat[fp + numDefineNeg86] = f1;
      f1 = f14 * f8;
      heapClassInst.heapFloat[fp + numDefineNeg83] = f1;
      f1 = f15 * f11;
      heapClassInst.heapFloat[fp + numDefineNeg88] = f1;
      f1 = f16 * f8;
      heapClassInst.heapFloat[fp + numDefineNeg85] = f1;
      f1 = f17 * f11;
      heapClassInst.heapFloat[fp + numDefineNeg92] = f1;
      f1 = f18 * f8;
      heapClassInst.heapFloat[fp + numDefineNeg87] = f1;
      f1 = f19 * f11;
      heapClassInst.heapFloat[fp + numDefineNeg93] = f1;
      f14 = f14 * f9;
      heapClassInst.heapFloat[fp + numDefineNeg89] = f14;
      f15 = f15 * f13;
      heapClassInst.heapFloat[fp + numDefineNeg94] = f15;
      f16 = f16 * f9;
      heapClassInst.heapFloat[fp + numDefineNeg90] = f16;
      f17 = f17 * f13;
      heapClassInst.heapFloat[fp + numDefineNeg95] = f17;
      f18 = f18 * f9;
      heapClassInst.heapFloat[fp + numDefineNeg91] = f18;
      f19 = f19 * f13;
      heapClassInst.heapFloat[fp + numDefineNeg96] = f19;
      f1 = heapClassInst.heapFloat[fp + numDefineNeg67];
      f7 = heapClassInst.heapFloat[fp + numDefineNeg69];
      f1 = f1 + f7;
      f7 = f30 * f6;
      f14 = heapClassInst.heapFloat[fp + numDefineNeg68];
      f15 = heapClassInst.heapFloat[fp + numDefineNeg71];
      f14 = f14 - f15;
      f15 = f30 * f20;
      f16 = heapClassInst.heapFloat[fp + numDefineNeg70];
      f17 = heapClassInst.heapFloat[fp + numDefineNeg73];
      f16 = f16 + f17;
      f17 = f3 * f6;
      f18 = heapClassInst.heapFloat[fp + numDefineNeg72];
      f19 = heapClassInst.heapFloat[fp + numDefineNeg78];
      f18 = f18 - f19;
      f19 = f3 * f20;
      f27 = heapClassInst.heapFloat[fp + numDefineNeg74];
      f28 = heapClassInst.heapFloat[fp + numDefineNeg76];
      f27 = f27 + f28;
      f6 = f26 * f6;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg75];
      f29 = heapClassInst.heapFloat[fp + numDefineNeg77];
      f28 = f28 - f29;
      f20 = f26 * f20;
      f29 = heapClassInst.heapFloat[fp + numDefineNeg63];
      f29 = f29 * f5;
      heapClassInst.heapFloat[fp + numDefineNeg67] = f29;
      f29 = f21 * f10;
      heapClassInst.heapFloat[fp + numDefineNeg69] = f29;
      f29 = f22 * f5;
      heapClassInst.heapFloat[fp + numDefineNeg68] = f29;
      f29 = f23 * f10;
      f5 = f24 * f5;
      heapClassInst.heapFloat[fp + numDefineNeg70] = f5;
      f5 = f25 * f10;
      heapClassInst.heapFloat[fp + numDefineNeg101] = f5;
      f10 = heapClassInst.heapFloat[fp + numDefineNeg63];
      f5 = f10 * f8;
      heapClassInst.heapFloat[fp + numDefineNeg71] = f5;
      f5 = f21 * f11;
      heapClassInst.heapFloat[fp + numDefineNeg73] = f5;
      f5 = f22 * f8;
      heapClassInst.heapFloat[fp + numDefineNeg72] = f5;
      f5 = f23 * f11;
      heapClassInst.heapFloat[fp + numDefineNeg100] = f5;
      f8 = f24 * f8;
      heapClassInst.heapFloat[fp + numDefineNeg74] = f8;
      f5 = f25 * f11;
      heapClassInst.heapFloat[fp + numDefineNeg102] = f5;
      f8 = f10 * f9;
      heapClassInst.heapFloat[fp + numDefineNeg75] = f8;
      f5 = f21 * f13;
      heapClassInst.heapFloat[fp + numDefineNeg103] = f5;
      f8 = f22 * f9;
      heapClassInst.heapFloat[fp + numDefineNeg78] = f8;
      f5 = f23 * f13;
      heapClassInst.heapFloat[fp + numDefineNeg104] = f5;
      f8 = f24 * f9;
      heapClassInst.heapFloat[fp + numDefineNeg76] = f8;
      f5 = f25 * f13;
      heapClassInst.heapFloat[fp + numDefineNeg105] = f5;
      f8 = heapClassInst.heapFloat[fp + numDefineNeg65];
      f9 = heapClassInst.heapFloat[fp + numDefineNeg99];
      f8 = f8 + f9;
      heapClassInst.heapFloat[fp + numDefineNeg77] = f8;
      f9 = f14 - f15;
      f1 = f1 + f7;
      heapClassInst.heapFloat[fp + numDefineNeg63] = f1;
      f7 = heapClassInst.heapFloat[fp + numDefineNeg66];
      f10 = heapClassInst.heapFloat[fp + numDefineNeg98];
      f7 = f7 + f10;
      heapClassInst.heapFloat[fp + numDefineNeg98] = f7;
      f10 = f18 - f19;
      f11 = f16 + f17;
      heapClassInst.heapFloat[fp + numDefineNeg65] = f11;
      f13 = heapClassInst.heapFloat[fp + numDefineNeg80];
      f14 = heapClassInst.heapFloat[fp + numDefineNeg97];
      f1 = f13 + f14;
      heapClassInst.heapFloat[fp + numDefineNeg80] = f1;
      f5 = f28 - f20;
      f6 = f27 + f6;
      heapClassInst.heapFloat[fp + numDefineNeg66] = f6;
      f7 = heapClassInst.heapFloat[fp + numDefineNeg64];
      f8 = heapClassInst.heapFloat[fp + numDefineNeg82];
      f1 = f7 + f8;
      heapClassInst.heapFloat[fp + numDefineNeg64] = f1;
      f1 = f0 * f30;
      heapClassInst.heapFloat[fp + numDefineNeg82] = f1;
      f6 = heapClassInst.heapFloat[fp + numDefineNeg79];
      f7 = heapClassInst.heapFloat[fp + numDefineNeg84];
      f1 = f6 + f7;
      heapClassInst.heapFloat[fp + numDefineNeg79] = f1;
      f1 = f2 * f30;
      heapClassInst.heapFloat[fp + numDefineNeg84] = f1;
      f6 = heapClassInst.heapFloat[fp + numDefineNeg81];
      f7 = heapClassInst.heapFloat[fp + numDefineNeg86];
      f1 = f6 + f7;
      heapClassInst.heapFloat[fp + numDefineNeg81] = f1;
      f1 = f4 * f30;
      heapClassInst.heapFloat[fp + numDefineNeg86] = f1;
      f6 = heapClassInst.heapFloat[fp + numDefineNeg83];
      f7 = heapClassInst.heapFloat[fp + numDefineNeg88];
      f1 = f6 + f7;
      heapClassInst.heapFloat[fp + numDefineNeg83] = f1;
      f1 = f0 * f3;
      heapClassInst.heapFloat[fp + numDefineNeg88] = f1;
      f6 = heapClassInst.heapFloat[fp + numDefineNeg85];
      f7 = heapClassInst.heapFloat[fp + numDefineNeg92];
      f1 = f6 + f7;
      heapClassInst.heapFloat[fp + numDefineNeg85] = f1;
      f1 = f2 * f3;
      heapClassInst.heapFloat[fp + numDefineNeg92] = f1;
      f6 = heapClassInst.heapFloat[fp + numDefineNeg87];
      f7 = heapClassInst.heapFloat[fp + numDefineNeg93];
      f1 = f6 + f7;
      heapClassInst.heapFloat[fp + numDefineNeg87] = f1;
      f1 = f4 * f3;
      heapClassInst.heapFloat[fp + numDefineNeg93] = f1;
      f6 = heapClassInst.heapFloat[fp + numDefineNeg89];
      f7 = heapClassInst.heapFloat[fp + numDefineNeg94];
      f1 = f6 + f7;
      heapClassInst.heapFloat[fp + numDefineNeg89] = f1;
      f0 = f0 * f26;
      f6 = heapClassInst.heapFloat[fp + numDefineNeg90];
      f7 = heapClassInst.heapFloat[fp + numDefineNeg95];
      f6 = f6 + f7;
      f2 = f2 * f26;
      f7 = heapClassInst.heapFloat[fp + numDefineNeg91];
      f8 = heapClassInst.heapFloat[fp + numDefineNeg96];
      f7 = f7 + f8;
      f4 = f4 * f26;
      f8 = heapClassInst.heapFloat[fp + numDefineNeg67];
      f11 = heapClassInst.heapFloat[fp + numDefineNeg69];
      f8 = f8 + f11;
      f11 = f12 * f30;
      f13 = heapClassInst.heapFloat[fp + numDefineNeg68];
      f13 = f13 + f29;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg62];
      f14 = f28 * f30;
      f15 = heapClassInst.heapFloat[fp + numDefineNeg70];
      f16 = heapClassInst.heapFloat[fp + numDefineNeg101];
      f15 = f15 + f16;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg61];
      f16 = f28 * f30;
      f17 = heapClassInst.heapFloat[fp + numDefineNeg71];
      f18 = heapClassInst.heapFloat[fp + numDefineNeg73];
      f17 = f17 + f18;
      f18 = f12 * f3;
      f19 = heapClassInst.heapFloat[fp + numDefineNeg72];
      f20 = heapClassInst.heapFloat[fp + numDefineNeg100];
      f19 = f19 + f20;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg62];
      f20 = f28 * f3;
      f21 = heapClassInst.heapFloat[fp + numDefineNeg74];
      f22 = heapClassInst.heapFloat[fp + numDefineNeg102];
      f21 = f21 + f22;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg61];
      f3 = f28 * f3;
      f22 = heapClassInst.heapFloat[fp + numDefineNeg75];
      f23 = heapClassInst.heapFloat[fp + numDefineNeg103];
      f22 = f22 + f23;
      f12 = f12 * f26;
      f23 = heapClassInst.heapFloat[fp + numDefineNeg78];
      f24 = heapClassInst.heapFloat[fp + numDefineNeg104];
      f23 = f23 + f24;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg62];
      f24 = f28 * f26;
      f25 = heapClassInst.heapFloat[fp + numDefineNeg76];
      f27 = heapClassInst.heapFloat[fp + numDefineNeg105];
      f25 = f25 + f27;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg61];
      f26 = f28 * f26;
      f27 = heapClassInst.heapFloat[fp + numDefineNeg77];
      f27 = f27 + f9;
      f28 = heapClassInst.heapFloat[fp + numDefineNeg98];
      f28 = f28 + f10;
      f29 = heapClassInst.heapFloat[fp + numDefineNeg80];
      f29 = f29 + f5;
      f30 = heapClassInst.heapFloat[fp + numDefineNeg64];
      f1 = heapClassInst.heapFloat[fp + numDefineNeg82];
      f1 = f30 + f1;
      heapClassInst.heapFloat[fp + numDefineNeg61] = f1;
      f1 = heapClassInst.heapFloat[fp + numDefineNeg79];
      f30 = heapClassInst.heapFloat[fp + numDefineNeg84];
      f1 = f1 + f30;
      heapClassInst.heapFloat[fp + numDefineNeg62] = f1;
      f1 = heapClassInst.heapFloat[fp + numDefineNeg81];
      f30 = heapClassInst.heapFloat[fp + numDefineNeg86];
      f1 = f1 + f30;
      heapClassInst.heapFloat[fp + numDefineNeg64] = f1;
      f1 = heapClassInst.heapFloat[fp + numDefineNeg83];
      f30 = heapClassInst.heapFloat[fp + numDefineNeg88];
      f1 = f1 + f30;
      heapClassInst.heapFloat[fp + numDefineNeg67] = f1;
      f1 = heapClassInst.heapFloat[fp + numDefineNeg85];
      f30 = heapClassInst.heapFloat[fp + numDefineNeg92];
      f1 = f1 + f30;
      heapClassInst.heapFloat[fp + numDefineNeg68] = f1;
      f1 = heapClassInst.heapFloat[fp + numDefineNeg87];
      f30 = heapClassInst.heapFloat[fp + numDefineNeg93];
      f1 = f1 + f30;
      f30 = heapClassInst.heapFloat[fp + numDefineNeg89];
      f0 = f30 + f0;
      f2 = f6 + f2;
      f4 = f7 + f4;
      f6 = heapClassInst.heapFloat[fp + numDefineNeg63];
      f6 = f6 + f9;
      f7 = heapClassInst.heapFloat[fp + numDefineNeg65];
      f7 = f7 + f10;
      f9 = heapClassInst.heapFloat[fp + numDefineNeg66];
      f5 = f9 + f5;
      f8 = f8 + f11;
      f9 = f13 + f14;
      f10 = f15 + f16;
      f11 = f17 + f18;
      f13 = f19 + f20;
      f3 = f21 + f3;
      f12 = f22 + f12;
      f14 = f23 + f24;
      f15 = f25 + f26;
      r0 = sp + numDefineNeg16;
      r4 = r0 >> numDefine2;
      heapClassInst.heapFloat[fp + numDefineNeg4] = f29;
      heapClassInst.heapFloat[r4 + 1] = f28;
      heapClassInst.heapFloat[r4 + numDefine2] = f27;
      heapClassInst.heap32[r4 + numDefine3] = 0;
      if (f5 < f29) {
        heapClassInst.heapFloat[fp + numDefineNeg4] = f5;
        f16 = f5;
      } else {
        f16 = f29;
      }
      if (f7 < f28) {
        heapClassInst.heapFloat[r4 + 1] = f7;
        f17 = f7;
      } else {
        f17 = f28;
      }
      if (f6 < f27) {
        heapClassInst.heapFloat[r4 + numDefine2] = f6;
        f18 = f6;
      } else {
        f18 = f27;
      }
      r5 = sp + numDefineNeg32;
      r6 = r5 >> numDefine2;
      heapClassInst.heapFloat[fp + numDefineNeg8] = f29;
      heapClassInst.heapFloat[r6 + 1] = f28;
      heapClassInst.heapFloat[r6 + numDefine2] = f27;
      heapClassInst.heap32[r6 + numDefine3] = 0;
      if (f29 < f5) {
        heapClassInst.heapFloat[fp + numDefineNeg8] = f5;
        f19 = f5;
      } else {
        f19 = f29;
      }
      if (f28 < f7) {
        heapClassInst.heapFloat[r6 + 1] = f7;
        f20 = f7;
      } else {
        f20 = f28;
      }
      if (f27 < f6) {
        heapClassInst.heapFloat[r6 + numDefine2] = f6;
        f21 = f6;
      } else {
        f21 = f27;
      }
      f22 = heapClassInst.heapFloat[r3 + numDefine61];
      f16 = f16 - f22;
      f17 = f17 - f22;
      heapClassInst.heapFloat[fp + numDefineNeg4] = f16;
      f16 = f18 - f22;
      heapClassInst.heapFloat[r4 + 1] = f17;
      f17 = f19 + f22;
      heapClassInst.heapFloat[r4 + numDefine2] = f16;
      f16 = f20 + f22;
      heapClassInst.heapFloat[fp + numDefineNeg8] = f17;
      r4 = zn33btCollisionObjectS1RK;
      f17 = f21 + f22;
      heapClassInst.heapFloat[r6 + 1] = f16;
      r7 = sp + numDefineNeg240;
      r4 = (r4 + numDefine8) | 0;
      heapClassInst.heapFloat[r6 + numDefine2] = f17;
      r6 = r7 >> numDefine2;
      heapClassInst.heap32[fp + numDefineNeg60] = r4;
      heapClassInst.heapFloat[r6 + 1] = f4;
      heapClassInst.heapFloat[r6 + numDefine2] = f2;
      heapClassInst.heapFloat[r6 + numDefine3] = f0;
      heapClassInst.heap32[r6 + numDefine4] = 0;
      heapClassInst.heapFloat[r6 + numDefine5] = f1;
      f0 = heapClassInst.heapFloat[fp + numDefineNeg68];
      heapClassInst.heapFloat[r6 + numDefine6] = f0;
      f0 = heapClassInst.heapFloat[fp + numDefineNeg67];
      heapClassInst.heapFloat[r6 + numDefine7] = f0;
      heapClassInst.heap32[r6 + numDefine8] = 0;
      f0 = heapClassInst.heapFloat[fp + numDefineNeg64];
      heapClassInst.heapFloat[r6 + numDefine9] = f0;
      f0 = heapClassInst.heapFloat[fp + numDefineNeg62];
      heapClassInst.heapFloat[r6 + numDefine10] = f0;
      f0 = heapClassInst.heapFloat[fp + numDefineNeg61];
      heapClassInst.heapFloat[r6 + numDefine11] = f0;
      heapClassInst.heap32[r6 + numDefine12] = 0;
      heapClassInst.heapFloat[r6 + numDefine13] = f29;
      heapClassInst.heapFloat[r6 + numDefine14] = f28;
      heapClassInst.heapFloat[r6 + numDefine15] = f27;
      heapClassInst.heap32[r6 + numDefine16] = 0;
      heapClassInst.heapFloat[r6 + numDefine17] = f15;
      heapClassInst.heapFloat[r6 + numDefine18] = f14;
      heapClassInst.heapFloat[r6 + numDefine19] = f12;
      heapClassInst.heap32[r6 + numDefine20] = 0;
      heapClassInst.heapFloat[r6 + numDefine21] = f3;
      heapClassInst.heapFloat[r6 + numDefine22] = f13;
      heapClassInst.heapFloat[r6 + numDefine23] = f11;
      heapClassInst.heap32[r6 + numDefine24] = 0;
      heapClassInst.heapFloat[r6 + numDefine25] = f10;
      heapClassInst.heapFloat[r6 + numDefine26] = f9;
      heapClassInst.heapFloat[r6 + numDefine27] = f8;
      heapClassInst.heap32[r6 + numDefine28] = 0;
      heapClassInst.heapFloat[r6 + numDefine29] = f5;
      heapClassInst.heapFloat[r6 + numDefine30] = f7;
      heapClassInst.heapFloat[r6 + numDefine31] = f6;
      heapClassInst.heap32[r6 + numDefine32] = 0;
      heapClassInst.heapFloat[r6 + numDefine49] = f22;
      heapClassInst.heap32[r6 + numDefine50] = heapClassInst.heap32[r3 + numDefine60];
      if (!(r1 === 0)) {
        r2 = heapClassInst.heap32[r2];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine15];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r7;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        heapClassInst.heap32[g0 + numDefine3] = r5;
        functionTable[r2 >> numDefine2](i7);
        f0 = heapClassInst.heapFloat[r6 + numDefine50];
        f1 = heapClassInst.heapFloat[r3 + numDefine60];
        if (!(f0 >= f1)) {
          heapClassInst.heapFloat[r3 + numDefine60] = f0;
          commonVariable.fg0 = f0;
          return;
        }
      }
    }
  }
  f0 = 1;
  commonVariable.fg0 = f0;
  return;
}

function zn33btConvexConcaveCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let f29: number = 0.0;
  let f30: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg80;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine8];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = r1 === 0 ? r2 : r3;
  r5 = r4 >> numDefine2;
  r5 = heapClassInst.heap32[r5 + numDefine48];
  r6 = r5 >> numDefine2;
  r7 = heapClassInst.heap32[r6 + 1];
  r7 = (r7 + numDefineNeg21) | 0;
  if (!(uint(r7) > uint(numDefine8))) {
    r1 = r1 === 0 ? r3 : r2;
    r2 = r1 >> numDefine2;
    r2 = heapClassInst.heap32[r2 + numDefine48];
    r2 = r2 >> numDefine2;
    r2 = heapClassInst.heap32[r2 + 1];
    if (!(r2 > numDefine19)) {
      r2 = heapClassInst.heap32[fp + numDefine3];
      r3 = heapClassInst.heap32[fp + numDefine4];
      r7 = heapClassInst.heap32[r6];
      r7 = r7 >> numDefine2;
      r7 = heapClassInst.heap32[r7 + numDefine11];
      heapClassInst.heap32[g0] = r5;
      r8 = r0 >> numDefine2;
      functionTable[r7 >> numDefine2](i7);
      f0 = commonVariable.fg0;
      r7 = r3 >> numDefine2;
      r9 = heapClassInst.heap32[r8 + numDefine19];
      heapClassInst.heap32[r7 + 1] = r9;
      heapClassInst.heap32[r8 + numDefine16] = r2;
      heapClassInst.heapFloat[r8 + numDefine17] = f0;
      heapClassInst.heap32[r8 + numDefine14] = r3;
      r2 = heapClassInst.heap32[r8 + numDefine4];
      r9 = heapClassInst.heap32[r8 + numDefine5];
      r9 = r9 >> numDefine2;
      r2 = r2 >> numDefine2;
      f1 = heapClassInst.heapFloat[r9 + 1];
      f2 = heapClassInst.heapFloat[r2 + 1];
      f3 = heapClassInst.heapFloat[r9 + numDefine5];
      f4 = heapClassInst.heapFloat[r2 + numDefine5];
      f5 = heapClassInst.heapFloat[r2 + numDefine2];
      f6 = heapClassInst.heapFloat[r2 + numDefine6];
      f7 = f2 * f1;
      f8 = f4 * f3;
      f9 = heapClassInst.heapFloat[r9 + numDefine9];
      f10 = heapClassInst.heapFloat[r2 + numDefine9];
      f11 = heapClassInst.heapFloat[r9 + numDefine2];
      f12 = heapClassInst.heapFloat[r9 + numDefine6];
      f13 = heapClassInst.heapFloat[r9 + numDefine3];
      f14 = heapClassInst.heapFloat[r2 + numDefine13];
      f15 = heapClassInst.heapFloat[r2 + numDefine3];
      f16 = heapClassInst.heapFloat[r9 + numDefine7];
      f17 = heapClassInst.heapFloat[r9 + numDefine14];
      f18 = heapClassInst.heapFloat[r2 + numDefine14];
      f19 = heapClassInst.heapFloat[r2 + numDefine7];
      f20 = heapClassInst.heapFloat[r9 + numDefine10];
      f21 = heapClassInst.heapFloat[r9 + numDefine15];
      f22 = heapClassInst.heapFloat[r9 + numDefine11];
      f23 = heapClassInst.heapFloat[r2 + numDefine15];
      f24 = heapClassInst.heapFloat[r2 + numDefine11];
      f25 = heapClassInst.heapFloat[r2 + numDefine10];
      f26 = heapClassInst.heapFloat[r9 + numDefine13];
      f27 = f5 * f1;
      f28 = f6 * f3;
      f7 = f7 + f8;
      f8 = f10 * f9;
      r9 = sp + numDefineNeg64;
      f29 = f15 * f1;
      f30 = f19 * f3;
      f27 = f27 + f28;
      f28 = f25 * f9;
      f7 = f7 + f8;
      r10 = r9 >> numDefine2;
      f8 = f29 + f30;
      f29 = f24 * f9;
      f27 = f27 + f28;
      heapClassInst.heapFloat[fp + numDefineNeg16] = f7;
      f7 = f2 * f11;
      f28 = f4 * f12;
      f8 = f8 + f29;
      heapClassInst.heapFloat[r10 + 1] = f27;
      heapClassInst.heapFloat[r10 + numDefine2] = f8;
      f8 = f5 * f11;
      f27 = f6 * f12;
      f7 = f7 + f28;
      f28 = f10 * f20;
      f29 = f15 * f11;
      f30 = f19 * f12;
      f8 = f8 + f27;
      f27 = f25 * f20;
      f7 = f7 + f28;
      heapClassInst.heap32[r10 + numDefine3] = 0;
      f28 = f29 + f30;
      f29 = f24 * f20;
      f8 = f8 + f27;
      heapClassInst.heapFloat[r10 + numDefine4] = f7;
      f2 = f2 * f13;
      f4 = f4 * f16;
      f7 = f28 + f29;
      heapClassInst.heapFloat[r10 + numDefine5] = f8;
      heapClassInst.heapFloat[r10 + numDefine6] = f7;
      f5 = f5 * f13;
      f6 = f6 * f16;
      f2 = f2 + f4;
      f4 = f10 * f22;
      f7 = -f26;
      f8 = f15 * f13;
      f10 = f19 * f16;
      f5 = f5 + f6;
      f6 = f25 * f22;
      f2 = f2 + f4;
      heapClassInst.heap32[r10 + numDefine7] = 0;
      f4 = f1 * f14;
      f15 = f3 * f18;
      f1 = f1 * f7;
      f3 = f3 * f17;
      f8 = f8 + f10;
      f10 = f24 * f22;
      f5 = f5 + f6;
      heapClassInst.heapFloat[r10 + numDefine8] = f2;
      f2 = f11 * f14;
      f6 = f12 * f18;
      f11 = f11 * f7;
      f12 = f12 * f17;
      f4 = f4 + f15;
      f15 = f9 * f23;
      f1 = f1 - f3;
      f3 = f9 * f21;
      f8 = f8 + f10;
      heapClassInst.heapFloat[r10 + numDefine9] = f5;
      heapClassInst.heapFloat[r10 + numDefine10] = f8;
      f5 = f13 * f14;
      f8 = f16 * f18;
      f7 = f13 * f7;
      f9 = f16 * f17;
      f2 = f2 + f6;
      f6 = f20 * f23;
      f10 = f11 - f12;
      f11 = f20 * f21;
      f4 = f4 + f15;
      f1 = f1 - f3;
      f3 = f5 + f8;
      f5 = f22 * f23;
      f7 = f7 - f9;
      f8 = f22 * f21;
      f2 = f2 + f6;
      f6 = f10 - f11;
      f1 = f4 + f1;
      heapClassInst.heap32[r10 + numDefine11] = 0;
      f3 = f3 + f5;
      f4 = f7 - f8;
      f2 = f2 + f6;
      heapClassInst.heapFloat[r10 + numDefine12] = f1;
      f1 = f3 + f4;
      heapClassInst.heapFloat[r10 + numDefine13] = f2;
      heapClassInst.heapFloat[r10 + numDefine14] = f1;
      heapClassInst.heap32[r10 + numDefine15] = 0;
      r2 = heapClassInst.heap32[r2 + numDefine48];
      r10 = r2 >> numDefine2;
      r10 = heapClassInst.heap32[r10];
      r10 = r10 >> numDefine2;
      r10 = heapClassInst.heap32[r10 + numDefine2];
      r11 = (r0 + numDefine40) | 0;
      r12 = (r0 + numDefine24) | 0;
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = r9;
      heapClassInst.heap32[g0 + numDefine2] = r12;
      heapClassInst.heap32[g0 + numDefine3] = r11;
      functionTable[r10 >> numDefine2](i7);
      f1 = heapClassInst.heapFloat[r8 + numDefine10];
      f1 = f1 + f0;
      heapClassInst.heapFloat[r8 + numDefine10] = f1;
      f1 = heapClassInst.heapFloat[r8 + numDefine11];
      f1 = f1 + f0;
      heapClassInst.heapFloat[r8 + numDefine11] = f1;
      f1 = heapClassInst.heapFloat[r8 + numDefine12];
      f1 = f1 + f0;
      heapClassInst.heapFloat[r8 + numDefine12] = f1;
      f1 = heapClassInst.heapFloat[r8 + numDefine6];
      f1 = f1 - f0;
      heapClassInst.heapFloat[r8 + numDefine6] = f1;
      f1 = heapClassInst.heapFloat[r8 + numDefine7];
      f1 = f1 - f0;
      heapClassInst.heapFloat[r8 + numDefine7] = f1;
      f1 = heapClassInst.heapFloat[r8 + numDefine8];
      f0 = f1 - f0;
      heapClassInst.heapFloat[r8 + numDefine8] = f0;
      r2 = heapClassInst.heap32[r8 + numDefine19];
      r2 = r2 >> numDefine2;
      heapClassInst.heap32[r2 + numDefine277] = r1;
      heapClassInst.heap32[r2 + numDefine278] = r4;
      r1 = heapClassInst.heap32[r6];
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine15];
      r0 = (r0 + numDefine12) | 0;
      heapClassInst.heap32[g0] = r5;
      heapClassInst.heap32[g0 + 1] = r0;
      heapClassInst.heap32[g0 + numDefine2] = r12;
      heapClassInst.heap32[g0 + numDefine3] = r11;
      functionTable[r1 >> numDefine2](i7);
      r0 = heapClassInst.heap32[r7 + 1];
      if (r0 !== 0) {
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine279];
        if (!(r2 === 0)) {
          r1 = heapClassInst.heap32[r1 + numDefine277];
          r2 = heapClassInst.heap32[r7 + numDefine34];
          if (r1 === r2) {
            r1 = (r3 + numDefine8) | 0;
            r2 = (r3 + numDefine72) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r2;
            zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
          } else {
            r1 = (r3 + numDefine72) | 0;
            r3 = (r3 + numDefine8) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r3;
            zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
            return;
          }
        }
      } else {
        r0 = twoEStr59;
        r3 = twoEStr160;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = numDefine101;
        assertNew(i7);
      }
    }
  }
  return;
}

function zn33btConvexConcaveCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine19];
  if (!(r1 === 0)) {
    r2 = heapClassInst.heap32[fp + 1];
    r3 = r2 >> numDefine2;
    r4 = heapClassInst.heap32[r3 + numDefine2];
    r5 = heapClassInst.heap32[r3 + 1];
    if (r4 === r5) {
      r6 = 1;
      r7 = r5 << 1;
      r7 = r5 === 0 ? r6 : r7;
      if (!(r4 >= r7)) {
        if (r7 !== 0) {
          r1 = gNumAlignedAllocs;
          r1 = r1 >> numDefine2;
          r4 = heapClassInst.heap32[r1];
          r8 = r7 << numDefine2;
          r4 = (r4 + 1) | 0;
          r8 = r8 | numDefine3;
          heapClassInst.heap32[r1] = r4;
          r1 = (r8 + numDefine16) | 0;
          heapClassInst.heap32[g0] = r1;
          mallocNew(i7);
          r1 = commonVariable.rg0;
          if (r1 !== 0) {
            r4 = 0;
            r8 = (r1 + numDefine4) | 0;
            r4 = (r4 - r8) | 0;
            r4 = r4 & numDefine15;
            r4 = (r1 + r4) | 0;
            r8 = (r4 + numDefine4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = r1;
            r1 = r8;
          }
        } else {
          r1 = 0;
        }
        r4 = (r2 + numDefine12) | 0;
        if (r5 < 1) {
          r8 = r4 >> numDefine2;
          r9 = heapClassInst.heap32[r8];
        } else {
          r8 = 0;
          repeat14: while (true) {
            r9 = r4 >> numDefine2;
            r9 = heapClassInst.heap32[r9];
            r10 = r8 << numDefine2;
            r11 = (r9 + r10) | 0;
            r11 = r11 >> numDefine2;
            r10 = (r1 + r10) | 0;
            r11 = heapClassInst.heap32[r11];
            r8 = (r8 + 1) | 0;
            r10 = r10 >> numDefine2;
            heapClassInst.heap32[r10] = r11;
            if (!(r5 !== r8)) {
              break repeat14;
            }
          }
          r4 = (r2 + numDefine12) | 0;
        }
        if (r9 !== 0) {
          r8 = heapClassInst.heapU8[r2 + numDefine16];
          if (r8 !== 0) {
            r5 = gNumAlignedFree;
            r5 = r5 >> numDefine2;
            r8 = heapClassInst.heap32[r5];
            r8 = (r8 + 1) | 0;
            r9 = r9 >> numDefine2;
            heapClassInst.heap32[r5] = r8;
            r5 = heapClassInst.heap32[r9 + -1];
            heapClassInst.heap32[g0] = r5;
            free(i7);
            r5 = heapClassInst.heap32[r3 + 1];
          }
          r8 = r4 >> numDefine2;
          heapClassInst.heap32[r8] = 0;
        }
        r4 = r4 >> numDefine2;
        heapClassInst.heap8[r2 + numDefine16] = r6;
        heapClassInst.heap32[r4] = r1;
        heapClassInst.heap32[r3 + numDefine2] = r7;
        r1 = heapClassInst.heap32[r0 + numDefine19];
      }
    }
    r0 = r5 << numDefine2;
    r2 = heapClassInst.heap32[r3 + numDefine3];
    r0 = (r2 + r0) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r3 + 1];
    r0 = (r0 + 1) | 0;
    heapClassInst.heap32[r3 + 1] = r0;
  }
  return;
}

function zn33btConvexConcaveCollisionAlgorithmD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv33btConvexConcaveCollisionAlgorithm;
  r2 = ztv24btConvexTriangleCallback;
  r1 = (r1 + numDefine8) | 0;
  r3 = r0 >> numDefine2;
  r2 = (r2 + numDefine8) | 0;
  heapClassInst.heap32[r3] = r1;
  heapClassInst.heap32[r3 + numDefine3] = r2;
  r1 = heapClassInst.heap32[r3 + numDefine15];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine5];
  r4 = heapClassInst.heap32[r3 + numDefine19];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r4;
  functionTable[r2 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r3 + numDefine15];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  r4 = heapClassInst.heap32[r3 + numDefine19];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r4;
  r1 = ztv18btTriangleCallback;
  r4 = ztv30btActivatingCollisionAlgorithm;
  r1 = (r1 + numDefine8) | 0;
  functionTable[r2 >> numDefine2](i7);
  r2 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r3 + numDefine3] = r1;
  heapClassInst.heap32[r3] = r2;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn33btConvexConcaveCollisionAlgorithmD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv33btConvexConcaveCollisionAlgorithm;
  r2 = ztv24btConvexTriangleCallback;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  r2 = (r2 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  heapClassInst.heap32[r0 + numDefine3] = r2;
  r1 = heapClassInst.heap32[r0 + numDefine15];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine5];
  r3 = heapClassInst.heap32[r0 + numDefine19];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r3;
  functionTable[r2 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r0 + numDefine15];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  r3 = heapClassInst.heap32[r0 + numDefine19];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r3;
  r1 = ztv18btTriangleCallback;
  r3 = ztv30btActivatingCollisionAlgorithm;
  r1 = (r1 + numDefine8) | 0;
  functionTable[r2 >> numDefine2](i7);
  r2 = (r3 + numDefine8) | 0;
  heapClassInst.heap32[r0 + numDefine3] = r1;
  heapClassInst.heap32[r0] = r2;
  return;
}

function zn23btConvexConvexAlgorithm10CreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn23btConvexConvexAlgorithm10CreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn23btConvexConvexAlgorithm10CreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn23btConvexConvexAlgorithm10CreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn23btConvexConvexAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine36;
  r1 = heapClassInst.heap32[fp];
  functionTable[r2 >> numDefine2](i7);
  r1 = r1 >> numDefine2;
  r3 = ztv20btCollisionAlgorithm;
  r4 = heapClassInst.heap32[r1 + numDefine5];
  r5 = heapClassInst.heap32[r1 + numDefine4];
  r6 = heapClassInst.heap32[r0 + 1];
  r7 = heapClassInst.heap32[r1 + numDefine2];
  r1 = heapClassInst.heap32[r1 + numDefine3];
  r8 = commonVariable.rg0 >> numDefine2;
  r3 = (r3 + numDefine8) | 0;
  heapClassInst.heap32[r8] = r3;
  r0 = heapClassInst.heap32[r0];
  r3 = ztv23btConvexConvexAlgorithm;
  r3 = (r3 + numDefine8) | 0;
  heapClassInst.heap32[r8 + 1] = r0;
  heapClassInst.heap32[r8] = r3;
  heapClassInst.heap32[r8 + numDefine2] = r1;
  r0 = 0;
  heapClassInst.heap32[r8 + numDefine3] = r7;
  heapClassInst.heap8[commonVariable.rg0 + numDefine16] = r0;
  heapClassInst.heap32[r8 + numDefine5] = r6;
  heapClassInst.heap8[commonVariable.rg0 + numDefine24] = r0;
  heapClassInst.heap32[r8 + numDefine7] = r5;
  heapClassInst.heap32[r8 + numDefine8] = r4;
  return;
}

function zn24btPerturbedContactResultD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv24btPerturbedContactResult;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn24btPerturbedContactResultD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv24btPerturbedContactResult;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn24btPerturbedContactResult15addContactPointERK9btVector3S2F(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let f29: number = 0.0;
  let f30: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg104;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp + numDefine2];
  r2 = r2 >> numDefine2;
  f0 = heapClassInst.heapFloat[r1 + numDefine2];
  heapClassInst.heapFloat[fp + numDefineNeg5] = f0;
  f1 = heapClassInst.heapFloat[r1 + 1];
  heapClassInst.heapFloat[fp + numDefineNeg6] = f1;
  f2 = heapClassInst.heapFloat[fp + numDefine3];
  f3 = heapClassInst.heapFloat[r1];
  heapClassInst.heapFloat[fp + numDefineNeg7] = f3;
  f4 = heapClassInst.heapFloat[r2 + numDefine2];
  heapClassInst.heapFloat[fp + numDefineNeg11] = f4;
  f0 = f0 * f2;
  f5 = heapClassInst.heapFloat[r2 + 1];
  heapClassInst.heapFloat[fp + numDefineNeg12] = f5;
  f1 = f1 * f2;
  f6 = heapClassInst.heapFloat[r2];
  heapClassInst.heapFloat[fp + numDefineNeg13] = f6;
  f2 = f3 * f2;
  r1 = heapClassInst.heap32[fp];
  f0 = f4 + f0;
  heapClassInst.heapFloat[fp + numDefineNeg8] = f0;
  f0 = f5 + f1;
  heapClassInst.heapFloat[fp + numDefineNeg9] = f0;
  f0 = f6 + f2;
  heapClassInst.heapFloat[fp + numDefineNeg10] = f0;
  r2 = heapClassInst.heapU8[r1 + numDefine356];
  if (r2 === 0) {
    r2 = r1 >> numDefine2;
    f3 = heapClassInst.heapFloat[r2 + numDefine69];
    f3 = -f3;
    f0 = heapClassInst.heapFloat[r2 + numDefine57];
    f1 = heapClassInst.heapFloat[r2 + numDefine58];
    f2 = heapClassInst.heapFloat[r2 + numDefine61];
    f4 = heapClassInst.heapFloat[r2 + numDefine70];
    f5 = heapClassInst.heapFloat[r2 + numDefine62];
    f6 = heapClassInst.heapFloat[r2 + numDefine77];
    f7 = heapClassInst.heapFloat[r2 + numDefine78];
    f8 = heapClassInst.heapFloat[r2 + numDefine73];
    f9 = heapClassInst.heapFloat[r2 + numDefine65];
    f10 = heapClassInst.heapFloat[r2 + numDefine74];
    f11 = heapClassInst.heapFloat[r2 + numDefine66];
    f12 = heapClassInst.heapFloat[r2 + numDefine71];
    f13 = heapClassInst.heapFloat[r2 + numDefine59];
    f14 = heapClassInst.heapFloat[r2 + numDefine63];
    f15 = f0 * f3;
    f16 = f2 * f4;
    f17 = f1 * f3;
    f18 = f5 * f4;
    f19 = heapClassInst.heapFloat[r2 + numDefine81];
    f20 = heapClassInst.heapFloat[r2 + numDefine82];
    f21 = heapClassInst.heapFloat[r2 + numDefine79];
    f22 = heapClassInst.heapFloat[r2 + numDefine67];
    f23 = heapClassInst.heapFloat[r2 + numDefine75];
    f24 = f0 * f6;
    f25 = f1 * f7;
    f26 = f2 * f6;
    f27 = f5 * f7;
    f28 = f0 * f8;
    heapClassInst.heapFloat[fp + numDefineNeg14] = f28;
    f28 = f1 * f10;
    heapClassInst.heapFloat[fp + numDefineNeg15] = f28;
    f29 = f2 * f8;
    f28 = f5 * f10;
    f15 = f15 - f16;
    f16 = f9 * f12;
    f17 = f17 - f18;
    f18 = f11 * f12;
    f3 = f13 * f3;
    heapClassInst.heapFloat[fp + numDefineNeg16] = f3;
    f3 = f14 * f4;
    heapClassInst.heapFloat[fp + numDefineNeg20] = f3;
    f4 = f15 - f16;
    f15 = f17 - f18;
    f16 = heapClassInst.heapFloat[r2 + numDefine83];
    f0 = f0 * f19;
    f1 = f1 * f20;
    f2 = f2 * f19;
    f5 = f5 * f20;
    f17 = f24 + f25;
    heapClassInst.heapFloat[fp + numDefineNeg17] = f17;
    f3 = f13 * f21;
    heapClassInst.heapFloat[fp + numDefineNeg21] = f3;
    f17 = f26 + f27;
    heapClassInst.heapFloat[fp + numDefineNeg18] = f17;
    f18 = f14 * f21;
    f24 = f9 * f6;
    heapClassInst.heapFloat[fp + numDefineNeg19] = f24;
    f25 = f11 * f7;
    f26 = heapClassInst.heapFloat[fp + numDefineNeg14];
    f27 = heapClassInst.heapFloat[fp + numDefineNeg15];
    f26 = f26 + f27;
    f27 = f13 * f23;
    f28 = f29 + f28;
    f29 = f14 * f23;
    f30 = f9 * f8;
    f3 = f11 * f10;
    f17 = heapClassInst.heapFloat[fp + numDefineNeg16];
    f24 = heapClassInst.heapFloat[fp + numDefineNeg20];
    f17 = f17 - f24;
    f12 = f22 * f12;
    f12 = f17 - f12;
    f0 = f0 + f1;
    f1 = f13 * f16;
    f2 = f2 + f5;
    f5 = f14 * f16;
    f9 = f9 * f19;
    f11 = f11 * f20;
    f17 = heapClassInst.heapFloat[fp + numDefineNeg17];
    f13 = heapClassInst.heapFloat[fp + numDefineNeg21];
    f13 = f17 + f13;
    f14 = f26 + f27;
    f17 = heapClassInst.heapFloat[fp + numDefineNeg18];
    f17 = f17 + f18;
    f18 = f28 + f29;
    f24 = heapClassInst.heapFloat[fp + numDefineNeg19];
    f24 = f24 + f25;
    f25 = f22 * f21;
    f6 = f6 * f4;
    f7 = f7 * f15;
    f3 = f30 + f3;
    f26 = f22 * f23;
    f8 = f8 * f4;
    f10 = f10 * f15;
    f0 = f0 + f1;
    f1 = f2 + f5;
    f2 = f9 + f11;
    f5 = f22 * f16;
    f4 = f19 * f4;
    f9 = f20 * f15;
    f11 = heapClassInst.heapFloat[fp + numDefineNeg13];
    f13 = f13 * f11;
    f15 = heapClassInst.heapFloat[fp + numDefineNeg12];
    f17 = f17 * f15;
    f19 = f24 + f25;
    f3 = f3 + f26;
    f6 = f6 + f7;
    f7 = f21 * f12;
    f14 = f14 * f11;
    f18 = f18 * f15;
    f8 = f8 + f10;
    f10 = f23 * f12;
    f2 = f2 + f5;
    f0 = f0 * f11;
    f1 = f1 * f15;
    f4 = f4 + f9;
    f5 = f16 * f12;
    f9 = f13 + f17;
    f11 = heapClassInst.heapFloat[fp + numDefineNeg11];
    f12 = f19 * f11;
    f6 = f6 + f7;
    f7 = heapClassInst.heapFloat[r2 + numDefine86];
    f13 = f14 + f18;
    f3 = f3 * f11;
    f8 = f8 + f10;
    f10 = heapClassInst.heapFloat[r2 + numDefine85];
    f14 = heapClassInst.heapFloat[r2 + numDefine87];
    f4 = f4 + f5;
    f0 = f0 + f1;
    f1 = f2 * f11;
    f2 = f9 + f12;
    f5 = f6 + f7;
    f3 = f13 + f3;
    f6 = f8 + f10;
    f3 = f3 + f6;
    f2 = f2 + f5;
    f0 = f0 + f1;
    f1 = f4 + f14;
    r2 = sp + numDefineNeg16;
    f4 = heapClassInst.heapFloat[fp + numDefineNeg10];
    f4 = f4 - f3;
    f5 = heapClassInst.heapFloat[fp + numDefineNeg9];
    f5 = f5 - f2;
    f0 = f0 + f1;
    f1 = heapClassInst.heapFloat[fp + numDefineNeg7];
    f1 = f4 * f1;
    f4 = heapClassInst.heapFloat[fp + numDefineNeg6];
    f4 = f5 * f4;
    f5 = heapClassInst.heapFloat[fp + numDefineNeg8];
    f5 = f5 - f0;
    r2 = r2 >> numDefine2;
    heapClassInst.heapFloat[fp + numDefineNeg4] = f3;
    heapClassInst.heapFloat[r2 + 1] = f2;
    f3 = f1 + f4;
    f1 = heapClassInst.heapFloat[fp + numDefineNeg5];
    f1 = f5 * f1;
    f3 = f3 + f1;
    heapClassInst.heapFloat[r2 + numDefine2] = f0;
    heapClassInst.heap32[r2 + numDefine3] = 0;
  } else {
    r2 = r1 >> numDefine2;
    f0 = heapClassInst.heapFloat[r2 + numDefine53];
    f0 = -f0;
    f1 = heapClassInst.heapFloat[r2 + numDefine41];
    f2 = heapClassInst.heapFloat[r2 + numDefine42];
    f3 = heapClassInst.heapFloat[r2 + numDefine45];
    f4 = heapClassInst.heapFloat[r2 + numDefine54];
    f5 = heapClassInst.heapFloat[r2 + numDefine46];
    f6 = heapClassInst.heapFloat[r2 + numDefine77];
    f7 = heapClassInst.heapFloat[r2 + numDefine78];
    f8 = heapClassInst.heapFloat[r2 + numDefine73];
    f9 = heapClassInst.heapFloat[r2 + numDefine49];
    f10 = heapClassInst.heapFloat[r2 + numDefine74];
    f11 = heapClassInst.heapFloat[r2 + numDefine50];
    f12 = heapClassInst.heapFloat[r2 + numDefine55];
    f13 = heapClassInst.heapFloat[r2 + numDefine43];
    f14 = heapClassInst.heapFloat[r2 + numDefine47];
    f15 = f1 * f0;
    f16 = f3 * f4;
    f17 = f2 * f0;
    f18 = f5 * f4;
    f19 = heapClassInst.heapFloat[r2 + numDefine81];
    f20 = heapClassInst.heapFloat[r2 + numDefine82];
    f21 = heapClassInst.heapFloat[r2 + numDefine79];
    f22 = heapClassInst.heapFloat[r2 + numDefine51];
    f23 = heapClassInst.heapFloat[r2 + numDefine75];
    f24 = f1 * f8;
    f25 = f2 * f10;
    f26 = f3 * f8;
    f27 = f5 * f10;
    f28 = f1 * f6;
    heapClassInst.heapFloat[fp + numDefineNeg14] = f28;
    f29 = f2 * f7;
    f30 = f3 * f6;
    f28 = f5 * f7;
    f15 = f15 - f16;
    f16 = f9 * f12;
    f17 = f17 - f18;
    f18 = f11 * f12;
    f0 = f13 * f0;
    heapClassInst.heapFloat[fp + numDefineNeg15] = f0;
    f0 = f14 * f4;
    heapClassInst.heapFloat[fp + numDefineNeg16] = f0;
    f4 = f15 - f16;
    f15 = f17 - f18;
    f16 = heapClassInst.heapFloat[r2 + numDefine83];
    f0 = f24 + f25;
    heapClassInst.heapFloat[fp + numDefineNeg17] = f0;
    f17 = f13 * f23;
    f0 = f26 + f27;
    heapClassInst.heapFloat[fp + numDefineNeg18] = f0;
    f18 = f14 * f23;
    f24 = f9 * f8;
    f25 = f11 * f10;
    f26 = heapClassInst.heapFloat[fp + numDefineNeg14];
    f26 = f26 + f29;
    f27 = f13 * f21;
    f28 = f30 + f28;
    f29 = f14 * f21;
    f30 = f9 * f6;
    f0 = f11 * f7;
    f1 = f1 * f19;
    heapClassInst.heapFloat[fp + numDefineNeg14] = f1;
    f2 = f2 * f20;
    f1 = f3 * f19;
    heapClassInst.heapFloat[fp + numDefineNeg19] = f1;
    f3 = f5 * f20;
    f5 = heapClassInst.heapFloat[fp + numDefineNeg15];
    f1 = heapClassInst.heapFloat[fp + numDefineNeg16];
    f1 = f5 - f1;
    f5 = f22 * f12;
    f1 = f1 - f5;
    f5 = heapClassInst.heapFloat[fp + numDefineNeg17];
    f5 = f5 + f17;
    f12 = f26 + f27;
    f17 = heapClassInst.heapFloat[fp + numDefineNeg18];
    f17 = f17 + f18;
    f18 = f28 + f29;
    f24 = f24 + f25;
    f25 = f22 * f23;
    f8 = f8 * f4;
    f10 = f10 * f15;
    f0 = f30 + f0;
    f26 = f22 * f21;
    f6 = f6 * f4;
    f7 = f7 * f15;
    f27 = heapClassInst.heapFloat[fp + numDefineNeg14];
    f2 = f27 + f2;
    f13 = f13 * f16;
    f27 = heapClassInst.heapFloat[fp + numDefineNeg19];
    f3 = f27 + f3;
    f14 = f14 * f16;
    f9 = f9 * f19;
    f11 = f11 * f20;
    f2 = f2 + f13;
    f3 = f3 + f14;
    f13 = heapClassInst.heapFloat[fp + numDefineNeg10];
    f5 = f5 * f13;
    f14 = heapClassInst.heapFloat[fp + numDefineNeg9];
    f17 = f17 * f14;
    f24 = f24 + f25;
    f0 = f0 + f26;
    f8 = f8 + f10;
    f10 = f23 * f1;
    f12 = f12 * f13;
    f18 = f18 * f14;
    f6 = f6 + f7;
    f7 = f21 * f1;
    f9 = f9 + f11;
    f11 = f22 * f16;
    f4 = f19 * f4;
    f15 = f20 * f15;
    f9 = f9 + f11;
    f5 = f5 + f17;
    f11 = heapClassInst.heapFloat[fp + numDefineNeg8];
    f17 = f24 * f11;
    f8 = f8 + f10;
    f10 = heapClassInst.heapFloat[r2 + numDefine85];
    f12 = f12 + f18;
    f0 = f0 * f11;
    f6 = f6 + f7;
    f7 = heapClassInst.heapFloat[r2 + numDefine86];
    f2 = f2 * f13;
    f3 = f3 * f14;
    f4 = f4 + f15;
    f1 = f16 * f1;
    f13 = heapClassInst.heapFloat[r2 + numDefine87];
    f1 = f4 + f1;
    f4 = f5 + f17;
    f5 = f8 + f10;
    f0 = f12 + f0;
    f6 = f6 + f7;
    f2 = f2 + f3;
    f3 = f9 * f11;
    f4 = f4 + f5;
    f0 = f0 + f6;
    f2 = f2 + f3;
    f1 = f1 + f13;
    f3 = heapClassInst.heapFloat[fp + numDefineNeg13];
    f3 = f4 - f3;
    f5 = heapClassInst.heapFloat[fp + numDefineNeg12];
    f5 = f0 - f5;
    f1 = f2 + f1;
    f2 = heapClassInst.heapFloat[fp + numDefineNeg7];
    f3 = f3 * f2;
    f6 = heapClassInst.heapFloat[fp + numDefineNeg6];
    f5 = f5 * f6;
    f7 = heapClassInst.heapFloat[fp + numDefineNeg11];
    f7 = f1 - f7;
    f3 = f3 + f5;
    f5 = heapClassInst.heapFloat[fp + numDefineNeg5];
    f7 = f7 * f5;
    f3 = f3 + f7;
    f2 = f2 * f3;
    r2 = sp + numDefineNeg16;
    f6 = f6 * f3;
    f2 = f4 + f2;
    f4 = f5 * f3;
    r2 = r2 >> numDefine2;
    f0 = f0 + f6;
    heapClassInst.heapFloat[fp + numDefineNeg4] = f2;
    f1 = f1 + f4;
    heapClassInst.heapFloat[r2 + 1] = f0;
    heapClassInst.heapFloat[r2 + numDefine2] = f1;
    heapClassInst.heap32[r2 + numDefine3] = 0;
  }
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine40];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  r3 = sp + numDefineNeg16;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  heapClassInst.heapFloat[g0 + numDefine3] = f3;
  functionTable[r2 >> numDefine2](i7);
  return;
}

function zn23btConvexConvexAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine5];
  if (!(r2 === 0)) {
    r0 = heapClassInst.heapU8[r0 + numDefine16];
    if (!(r0 === 0)) {
      r0 = heapClassInst.heap32[fp + 1];
      r3 = r0 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine2];
      r5 = heapClassInst.heap32[r3 + 1];
      if (r4 === r5) {
        r6 = 1;
        r7 = r5 << 1;
        r7 = r5 === 0 ? r6 : r7;
        if (!(r4 >= r7)) {
          if (r7 !== 0) {
            r2 = gNumAlignedAllocs;
            r2 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r2];
            r8 = r7 << numDefine2;
            r4 = (r4 + 1) | 0;
            r8 = r8 | numDefine3;
            heapClassInst.heap32[r2] = r4;
            r2 = (r8 + numDefine16) | 0;
            heapClassInst.heap32[g0] = r2;
            mallocNew(i7);
            r2 = commonVariable.rg0;
            if (r2 !== 0) {
              r4 = 0;
              r8 = (r2 + numDefine4) | 0;
              r4 = (r4 - r8) | 0;
              r4 = r4 & numDefine15;
              r4 = (r2 + r4) | 0;
              r8 = (r4 + numDefine4) | 0;
              r4 = r4 >> numDefine2;
              heapClassInst.heap32[r4] = r2;
              r2 = r8;
            }
          } else {
            r2 = 0;
          }
          r4 = (r0 + numDefine12) | 0;
          if (r5 < 1) {
            r8 = r4 >> numDefine2;
            r9 = heapClassInst.heap32[r8];
          } else {
            r8 = 0;
            repeat15: while (true) {
              r9 = r4 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r10 = r8 << numDefine2;
              r11 = (r9 + r10) | 0;
              r11 = r11 >> numDefine2;
              r10 = (r2 + r10) | 0;
              r11 = heapClassInst.heap32[r11];
              r8 = (r8 + 1) | 0;
              r10 = r10 >> numDefine2;
              heapClassInst.heap32[r10] = r11;
              if (!(r5 !== r8)) {
                break repeat15;
              }
            }
            r4 = (r0 + numDefine12) | 0;
          }
          if (r9 !== 0) {
            r8 = heapClassInst.heapU8[r0 + numDefine16];
            if (r8 !== 0) {
              r5 = gNumAlignedFree;
              r5 = r5 >> numDefine2;
              r8 = heapClassInst.heap32[r5];
              r8 = (r8 + 1) | 0;
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r5] = r8;
              r5 = heapClassInst.heap32[r9 + -1];
              heapClassInst.heap32[g0] = r5;
              free(i7);
              r5 = heapClassInst.heap32[r3 + 1];
            }
            r8 = r4 >> numDefine2;
            heapClassInst.heap32[r8] = 0;
          }
          r4 = r4 >> numDefine2;
          heapClassInst.heap8[r0 + numDefine16] = r6;
          heapClassInst.heap32[r4] = r2;
          heapClassInst.heap32[r3 + numDefine2] = r7;
          r2 = heapClassInst.heap32[r1 + numDefine5];
        }
      }
      r0 = r5 << numDefine2;
      r1 = heapClassInst.heap32[r3 + numDefine3];
      r0 = (r1 + r0) | 0;
      r0 = r0 >> numDefine2;
      heapClassInst.heap32[r0] = r2;
      r0 = heapClassInst.heap32[r3 + 1];
      r0 = (r0 + 1) | 0;
      heapClassInst.heap32[r3 + 1] = r0;
    }
  }
  return;
}

function zn23btConvexConvexAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg1240;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = r2 >> numDefine2;
  f0 = heapClassInst.heapFloat[r1 + numDefine29];
  f1 = heapClassInst.heapFloat[r1 + numDefine13];
  f2 = heapClassInst.heapFloat[r1 + numDefine30];
  f3 = heapClassInst.heapFloat[r1 + numDefine14];
  f0 = f0 - f1;
  f1 = f2 - f3;
  f2 = heapClassInst.heapFloat[r1 + numDefine31];
  f3 = heapClassInst.heapFloat[r1 + numDefine15];
  f2 = f2 - f3;
  f0 = f0 * f0;
  f1 = f1 * f1;
  f3 = heapClassInst.heapFloat[r1 + numDefine62];
  f0 = f0 + f1;
  f1 = f2 * f2;
  f2 = f3 * f3;
  f0 = f0 + f1;
  if (!(f2 <= f0)) {
    f0 = heapClassInst.heapFloat[r3 + numDefine31];
    f1 = heapClassInst.heapFloat[r3 + numDefine15];
    f2 = heapClassInst.heapFloat[r3 + numDefine30];
    f3 = heapClassInst.heapFloat[r3 + numDefine14];
    f4 = heapClassInst.heapFloat[r3 + numDefine29];
    f5 = heapClassInst.heapFloat[r3 + numDefine13];
    f0 = f0 - f1;
    f1 = f2 - f3;
    f2 = f4 - f5;
    f2 = f2 * f2;
    f1 = f1 * f1;
    f3 = heapClassInst.heapFloat[r3 + numDefine62];
    f1 = f2 + f1;
    f0 = f0 * f0;
    f2 = f3 * f3;
    f0 = f1 + f0;
    if (f2 > f0) {
      f0 = 1;
      commonVariable.fg0 = f0;
      return;
    }
  }
  r4 = sp + numDefineNeg56;
  r5 = heapClassInst.heap32[r1 + numDefine48];
  f0 = heapClassInst.heapFloat[r3 + numDefine61];
  r6 = r4 >> numDefine2;
  heapClassInst.heap32[r6 + numDefine2] = 0;
  heapClassInst.heap32[r6 + numDefine3] = numDefine53216;
  heapClassInst.heap32[r6 + numDefine4] = numDefine53216;
  r7 = ztv13btSphereShape;
  heapClassInst.heap32[r6 + numDefine5] = numDefine53216;
  r7 = (r7 + numDefine8) | 0;
  heapClassInst.heap32[r6 + numDefine6] = 0;
  heapClassInst.heap32[fp + numDefineNeg14] = r7;
  heapClassInst.heap32[r6 + 1] = numDefine8;
  r8 = ztvn12btConvexCast10CastResultE;
  heapClassInst.heapFloat[r6 + numDefine7] = f0;
  r9 = sp + numDefineNeg232;
  r8 = (r8 + numDefine8) | 0;
  heapClassInst.heapFloat[r6 + numDefine11] = f0;
  r6 = r9 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg58] = r8;
  heapClassInst.heap32[r6 + numDefine41] = numDefine44395;
  r10 = sp + numDefineNeg592;
  heapClassInst.heap32[r6 + numDefine42] = 0;
  r11 = r10 >> numDefine2;
  heapClassInst.heap32[r6 + numDefine43] = 0;
  r12 = ztv15btGjkConvexCast;
  r13 = 0;
  heapClassInst.heap32[r11 + numDefine77] = numDefine67991;
  r11 = sp + numDefineNeg608;
  r12 = (r12 + numDefine8) | 0;
  heapClassInst.heap8[sp + numDefineNeg260] = r13;
  r13 = r11 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg152] = r12;
  heapClassInst.heap32[r13 + 1] = r10;
  heapClassInst.heap32[r13 + numDefine2] = r5;
  heapClassInst.heap32[r13 + numDefine3] = r4;
  r4 = (r2 + numDefine68) | 0;
  r2 = (r2 + numDefine4) | 0;
  r5 = (r0 + numDefine68) | 0;
  r0 = (r0 + numDefine4) | 0;
  heapClassInst.heap32[g0] = r11;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  heapClassInst.heap32[g0 + numDefine3] = r2;
  heapClassInst.heap32[g0 + numDefine4] = r4;
  heapClassInst.heap32[g0 + numDefine5] = r9;
  zn15btGjkConvexCast16calcTimeCast10Cast(i7);
  r9 = commonVariable.rg0;
  if (r9 !== 0) {
    f0 = heapClassInst.heapFloat[r6 + numDefine41];
    f1 = heapClassInst.heapFloat[r1 + numDefine60];
    if (!(f1 <= f0)) {
      heapClassInst.heapFloat[r1 + numDefine60] = f0;
    }
    f1 = heapClassInst.heapFloat[r3 + numDefine60];
    if (!(f1 <= f0)) {
      heapClassInst.heapFloat[r3 + numDefine60] = f0;
    }
    f1 = 1;
    if (f0 >= f1) {
      label = numDefine3;
    } else {
      label = numDefine9;
    }
  } else {
    label = numDefine3;
  }
  if (label === numDefine3) {
    f0 = 1;
  }
  r6 = ztv12btConvexCast;
  r9 = ztv13btConvexShape;
  r6 = (r6 + numDefine8) | 0;
  r9 = (r9 + numDefine8) | 0;
  heapClassInst.heap32[fp + numDefineNeg152] = r6;
  heapClassInst.heap32[fp + numDefineNeg14] = r9;
  r6 = sp + numDefineNeg664;
  r9 = heapClassInst.heap32[r3 + numDefine48];
  f1 = heapClassInst.heapFloat[r1 + numDefine61];
  r10 = r6 >> numDefine2;
  heapClassInst.heap32[r10 + numDefine2] = 0;
  heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
  heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
  heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
  heapClassInst.heap32[r10 + numDefine6] = 0;
  heapClassInst.heap32[fp + numDefineNeg166] = r7;
  heapClassInst.heap32[r10 + 1] = numDefine8;
  heapClassInst.heapFloat[r10 + numDefine7] = f1;
  r7 = sp + numDefineNeg840;
  heapClassInst.heapFloat[r10 + numDefine11] = f1;
  r10 = r7 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg210] = r8;
  heapClassInst.heap32[r10 + numDefine41] = numDefine44395;
  r8 = sp + numDefineNeg1200;
  heapClassInst.heap32[r10 + numDefine42] = 0;
  r11 = r8 >> numDefine2;
  heapClassInst.heap32[r10 + numDefine43] = 0;
  heapClassInst.heap32[r11 + numDefine77] = numDefine67991;
  r11 = heapClassInst.heapU8[sp + numDefineNeg868];
  r11 = r11 & numDefine240;
  r13 = sp + numDefineNeg1216;
  heapClassInst.heap8[sp + numDefineNeg868] = r11;
  r11 = r13 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg304] = r12;
  heapClassInst.heap32[r11 + 1] = r8;
  heapClassInst.heap32[r11 + numDefine2] = r6;
  heapClassInst.heap32[r11 + numDefine3] = r9;
  heapClassInst.heap32[g0] = r13;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  heapClassInst.heap32[g0 + numDefine3] = r2;
  heapClassInst.heap32[g0 + numDefine4] = r4;
  heapClassInst.heap32[g0 + numDefine5] = r7;
  zn15btGjkConvexCast16calcTimeCast10Cast(i7);
  r0 = commonVariable.rg0;
  if (!(r0 === 0)) {
    f1 = heapClassInst.heapFloat[r10 + numDefine41];
    f2 = heapClassInst.heapFloat[r1 + numDefine60];
    if (!(f2 <= f1)) {
      heapClassInst.heapFloat[r1 + numDefine60] = f1;
    }
    f2 = heapClassInst.heapFloat[r3 + numDefine60];
    if (!(f2 <= f1)) {
      heapClassInst.heapFloat[r3 + numDefine60] = f1;
    }
    f0 = f1 < f0 ? f1 : f0;
  }
  commonVariable.fg0 = f0;
  return;
}

function zn23btConvexConvexAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let f29: number = 0.0;
  let f30: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg816;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine5];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  r5 = heapClassInst.heap32[fp + numDefine3];
  r6 = heapClassInst.heap32[fp + numDefine4];
  if (r2 === 0) {
    r2 = heapClassInst.heap32[r1 + 1];
    r7 = r2 >> numDefine2;
    r7 = heapClassInst.heap32[r7];
    r7 = r7 >> numDefine2;
    r7 = heapClassInst.heap32[r7 + numDefine3];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    functionTable[r7 >> numDefine2](i7);
    r2 = commonVariable.rg0;
    r7 = 1;
    heapClassInst.heap32[r1 + numDefine5] = r2;
    heapClassInst.heap8[r0 + numDefine16] = r7;
  }
  r7 = r6 >> numDefine2;
  r8 = r3 >> numDefine2;
  heapClassInst.heap32[r7 + 1] = r2;
  r2 = r4 >> numDefine2;
  r9 = heapClassInst.heap32[r8 + numDefine48];
  r10 = heapClassInst.heap32[r2 + numDefine48];
  r11 = r9 >> numDefine2;
  r12 = heapClassInst.heap32[r11 + 1];
  if (r12 !== numDefine10) {
    label = numDefine4;
  } else {
    r12 = r10 >> numDefine2;
    r13 = heapClassInst.heap32[r12 + 1];
    if (r13 === numDefine10) {
      r0 = heapClassInst.heap32[r11];
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0 + numDefine7];
      heapClassInst.heap32[g0] = r9;
      functionTable[r0 >> numDefine2](i7);
      r0 = heapClassInst.heap32[r12];
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0 + numDefine7];
      heapClassInst.heap32[g0] = r10;
      functionTable[r0 >> numDefine2](i7);
      r0 = heapClassInst.heap32[r11 + numDefine13];
      r5 = heapClassInst.heap32[r12 + numDefine13];
      r11 = r5 << numDefine2;
      r12 = r0 << numDefine2;
      r3 = (r3 + r12) | 0;
      r4 = (r4 + r11) | 0;
      r3 = r3 >> numDefine2;
      r4 = r4 >> numDefine2;
      r5 = (r5 + numDefine2) | 0;
      r0 = (r0 + numDefine2) | 0;
      f0 = heapClassInst.heapFloat[r3 + 1];
      f1 = heapClassInst.heapFloat[r4 + 1];
      f2 = heapClassInst.heapFloat[r3 + numDefine5];
      f3 = heapClassInst.heapFloat[r4 + numDefine5];
      r5 = r5 % numDefine3 | 0;
      r0 = r0 % numDefine3 | 0;
      f4 = heapClassInst.heapFloat[r3 + numDefine9];
      f5 = heapClassInst.heapFloat[r4 + numDefine9];
      f6 = f0 * f1;
      f7 = f2 * f3;
      f8 = heapClassInst.heapFloat[r2 + numDefine13];
      f9 = heapClassInst.heapFloat[r8 + numDefine13];
      f10 = heapClassInst.heapFloat[r2 + numDefine14];
      f11 = heapClassInst.heapFloat[r8 + numDefine14];
      f8 = f8 - f9;
      f9 = f10 - f11;
      r3 = (r10 + numDefine28) | 0;
      r4 = r5 << numDefine2;
      r5 = (r9 + numDefine28) | 0;
      r0 = r0 << numDefine2;
      f6 = f6 + f7;
      f7 = f4 * f5;
      f10 = heapClassInst.heapFloat[r2 + numDefine15];
      f11 = heapClassInst.heapFloat[r8 + numDefine15];
      f10 = f10 - f11;
      f6 = f6 + f7;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      r4 = (r3 + r4) | 0;
      r3 = (r3 + r11) | 0;
      r0 = (r5 + r0) | 0;
      r5 = (r5 + r12) | 0;
      f7 = f0 * f8;
      f11 = f2 * f9;
      f12 = f1 * f8;
      f13 = f3 * f9;
      r1 = r1 >> numDefine2;
      r4 = r4 >> numDefine2;
      r3 = r3 >> numDefine2;
      r0 = r0 >> numDefine2;
      r5 = r5 >> numDefine2;
      f14 = 1;
      f15 = f6 * f6;
      f7 = f7 + f11;
      f11 = f4 * f10;
      f12 = f12 + f13;
      f13 = f5 * f10;
      f15 = f14 - f15;
      f16 = heapClassInst.heapFloat[r1 + numDefine280];
      f17 = heapClassInst.heapFloat[r4];
      f18 = heapClassInst.heapFloat[r3];
      f19 = heapClassInst.heapFloat[r0];
      f20 = heapClassInst.heapFloat[r5];
      f7 = f7 + f11;
      f11 = f12 + f13;
      f12 = 0;
      if (f15 !== f12) {
        f13 = f11 * f6;
        f13 = f7 - f13;
        f13 = f13 / f15;
        f15 = -f20;
        if (f13 >= f15) {
          if (f13 > f20) {
            f15 = f20;
          } else {
            f15 = f13;
          }
        }
      } else {
        f15 = 0;
      }
      f13 = f15 * f6;
      f11 = f13 - f11;
      f13 = -f18;
      if (f11 >= f13) {
        if (f11 > f18) {
          f13 = f6 * f18;
          f6 = f13 + f7;
          f15 = -f20;
          if (f6 >= f15) {
            if (f6 > f20) {
              f13 = f18;
              f15 = f20;
            } else {
              f13 = f18;
              f15 = f6;
            }
          } else {
            f13 = f18;
          }
        } else {
          f13 = f11;
        }
      } else {
        f6 = f6 * f13;
        f6 = f6 + f7;
        f15 = -f20;
        if (f6 >= f15) {
          if (f6 > f20) {
            f15 = f20;
          } else {
            f15 = f6;
          }
        }
      }
      f6 = f0 * f15;
      f7 = f2 * f15;
      f1 = f1 * f13;
      f6 = f8 - f6;
      f3 = f3 * f13;
      f7 = f9 - f7;
      f8 = f4 * f15;
      f6 = f6 + f1;
      f7 = f7 + f3;
      f5 = f5 * f13;
      f8 = f10 - f8;
      f8 = f8 + f5;
      f9 = f6 * f6;
      f10 = f7 * f7;
      f9 = f9 + f10;
      f10 = f8 * f8;
      f9 = f9 + f10;
      heapClassInst.heapFloat[g0] = f9;
      sqrtf(i7);
      f10 = commonVariable.fg0 - f19;
      f10 = f10 - f17;
      if (!(f10 > f16)) {
        f11 = numDefineFloat4044;
        if (f9 > f11) {
          heapClassInst.heapFloat[g0] = f9;
          f0 = -1;
          sqrtf(i7);
          f0 = f0 / commonVariable.fg0;
          f9 = f6 * f0;
          r0 = sp + numDefineNeg16;
          f6 = f7 * f0;
          r0 = r0 >> numDefine2;
          heapClassInst.heapFloat[fp + numDefineNeg4] = f9;
          f12 = f8 * f0;
          heapClassInst.heapFloat[r0 + 1] = f6;
          heapClassInst.heapFloat[r0 + numDefine2] = f12;
          heapClassInst.heap32[r0 + numDefine3] = 0;
        } else {
          if (f4 < f12) {
            f6 = -f4;
          } else {
            f6 = f4;
          }
          f7 = numDefineFloat742;
          if (f6 <= f7) {
            f6 = f0 * f0;
            f9 = f2 * f2;
            f6 = f6 + f9;
            heapClassInst.heapFloat[g0] = f6;
            sqrtf(i7);
            f6 = f14 / commonVariable.fg0;
            f9 = -f2;
            f9 = f6 * f9;
            r0 = sp + numDefineNeg16;
            f6 = f0 * f6;
            r0 = r0 >> numDefine2;
            heapClassInst.heapFloat[fp + numDefineNeg4] = f9;
            heapClassInst.heapFloat[r0 + 1] = f6;
            heapClassInst.heap32[r0 + numDefine2] = 0;
          } else {
            f0 = f2 * f2;
            f6 = f4 * f4;
            f0 = f0 + f6;
            heapClassInst.heapFloat[g0] = f0;
            sqrtf(i7);
            r0 = sp + numDefineNeg16;
            f0 = f14 / commonVariable.fg0;
            f6 = -f4;
            f6 = f0 * f6;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg4] = 0;
            f9 = 0;
            f12 = f2 * f0;
            heapClassInst.heapFloat[r0 + 1] = f6;
            heapClassInst.heapFloat[r0 + numDefine2] = f12;
          }
        }
        f0 = heapClassInst.heapFloat[r2 + numDefine13];
        f2 = heapClassInst.heapFloat[r2 + numDefine14];
        f4 = heapClassInst.heapFloat[r2 + numDefine15];
        f0 = f0 + f1;
        f1 = f9 * f17;
        r0 = sp + numDefineNeg32;
        f2 = f2 + f3;
        f3 = f6 * f17;
        f0 = f0 + f1;
        r0 = r0 >> numDefine2;
        f1 = f4 + f5;
        f4 = f12 * f17;
        f2 = f2 + f3;
        heapClassInst.heapFloat[fp + numDefineNeg8] = f0;
        f0 = f1 + f4;
        heapClassInst.heapFloat[r0 + 1] = f2;
        heapClassInst.heapFloat[r0 + numDefine2] = f0;
        heapClassInst.heap32[r0 + numDefine3] = 0;
      }
      if (!(f10 >= f16)) {
        r0 = sp + numDefineNeg16;
        r1 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[fp + numDefineNeg4];
        f1 = heapClassInst.heapFloat[r1 + 1];
        f2 = heapClassInst.heapFloat[r1 + numDefine2];
        f0 = f0 * f0;
        f1 = f1 * f1;
        f0 = f0 + f1;
        f1 = f2 * f2;
        f0 = f0 + f1;
        f1 = numDefineFloat4044;
        if (f0 >= f1) {
          r1 = heapClassInst.heap32[r7];
          r1 = r1 >> numDefine2;
          r1 = heapClassInst.heap32[r1 + numDefine4];
          r2 = sp + numDefineNeg32;
          heapClassInst.heap32[g0] = r6;
          heapClassInst.heap32[g0 + 1] = r0;
          heapClassInst.heap32[g0 + numDefine2] = r2;
          heapClassInst.heapFloat[g0 + numDefine3] = f10;
          functionTable[r1 >> numDefine2](i7);
        } else {
          r0 = twoEStr4119;
          r1 = twoEStr5120;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r1;
          heapClassInst.heap32[g0 + numDefine2] = numDefine325;
          assertNew(i7);
        }
      }
      r0 = heapClassInst.heap32[r7 + 1];
      if (r0 !== 0) {
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine279];
        if (r2 === 0) {
          label = numDefine44;
        } else {
          r1 = heapClassInst.heap32[r1 + numDefine277];
          r2 = heapClassInst.heap32[r7 + numDefine34];
          if (r1 === r2) {
            label = numDefine43;
          } else {
            r1 = (r6 + numDefine72) | 0;
            r2 = (r6 + numDefine8) | 0;
            label = numDefine42;
          }
        }
      } else {
        r0 = twoEStr59;
        r1 = twoEStr160;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine101;
        assertNew(i7);
      }
    } else {
      label = numDefine4;
    }
  }
  if (label === numDefine4) {
    r3 = sp + numDefineNeg168;
    r4 = r3 >> numDefine2;
    heapClassInst.heap32[r4 + numDefine32] = numDefine44395;
    heapClassInst.heap32[r4 + numDefine33] = 0;
    r12 = ztv17btGjkPairDetector;
    r13 = heapClassInst.heap32[r1 + numDefine2];
    r14 = heapClassInst.heap32[r1 + numDefine3];
    r15 = sp + numDefineNeg248;
    r12 = (r12 + numDefine8) | 0;
    heapClassInst.heap32[fp + numDefineNeg62] = r12;
    r12 = r15 >> numDefine2;
    heapClassInst.heap32[r12 + 1] = 0;
    heapClassInst.heap32[r12 + numDefine2] = numDefine53216;
    heapClassInst.heap32[r12 + numDefine3] = 0;
    heapClassInst.heap32[r12 + numDefine4] = 0;
    heapClassInst.heap32[r12 + numDefine5] = r14;
    heapClassInst.heap32[r12 + numDefine6] = r13;
    heapClassInst.heap32[r12 + numDefine7] = r9;
    heapClassInst.heap32[r12 + numDefine8] = r10;
    r13 = heapClassInst.heap32[r11 + 1];
    heapClassInst.heap32[r12 + numDefine9] = r13;
    r13 = r10 >> numDefine2;
    r14 = heapClassInst.heap32[r13 + 1];
    heapClassInst.heap32[r12 + numDefine10] = r14;
    r14 = heapClassInst.heap32[r11];
    r14 = r14 >> numDefine2;
    r14 = heapClassInst.heap32[r14 + numDefine11];
    heapClassInst.heap32[g0] = r9;
    functionTable[r14 >> numDefine2](i7);
    heapClassInst.heapFloat[r12 + numDefine11] = commonVariable.fg0;
    r14 = heapClassInst.heap32[r13];
    r14 = r14 >> numDefine2;
    r14 = heapClassInst.heap32[r14 + numDefine11];
    heapClassInst.heap32[g0] = r10;
    functionTable[r14 >> numDefine2](i7);
    r14 = 0;
    heapClassInst.heapFloat[r12 + numDefine12] = commonVariable.fg0;
    heapClassInst.heap8[sp + numDefineNeg196] = r14;
    heapClassInst.heap32[r12 + numDefine15] = -1;
    heapClassInst.heap32[r12 + numDefine18] = 1;
    heapClassInst.heap32[r12 + numDefine7] = r9;
    heapClassInst.heap32[r12 + numDefine8] = r10;
    r16 = heapClassInst.heap32[r11];
    r16 = r16 >> numDefine2;
    r17 = heapClassInst.heapU8[r5 + numDefine40];
    r16 = heapClassInst.heap32[r16 + numDefine11];
    heapClassInst.heap32[g0] = r9;
    functionTable[r16 >> numDefine2](i7);
    f0 = commonVariable.fg0;
    r16 = heapClassInst.heap32[r13];
    r16 = r16 >> numDefine2;
    r16 = heapClassInst.heap32[r16 + numDefine11];
    heapClassInst.heap32[g0] = r10;
    functionTable[r16 >> numDefine2](i7);
    f0 = f0 + commonVariable.fg0;
    r16 = heapClassInst.heap32[r1 + numDefine5];
    if (r17 === 0) {
      r16 = (r16 + numDefine1120) | 0;
    } else {
      r16 = (r16 + numDefine1124) | 0;
    }
    r16 = r16 >> numDefine2;
    f1 = heapClassInst.heapFloat[r16];
    f0 = f0 + f1;
    f0 = f0 * f0;
    r5 = r5 >> numDefine2;
    heapClassInst.heapFloat[r4 + numDefine32] = f0;
    r16 = heapClassInst.heap32[r5 + numDefine11];
    heapClassInst.heap32[r4 + numDefine33] = r16;
    heapClassInst.heap32[fp + numDefineNeg42] = heapClassInst.heap32[r8 + 1];
    heapClassInst.heap32[r4 + 1] = heapClassInst.heap32[r8 + numDefine2];
    heapClassInst.heap32[r4 + numDefine2] = heapClassInst.heap32[r8 + numDefine2];
    heapClassInst.heap32[r4 + numDefine3] = heapClassInst.heap32[r8 + numDefine4];
    heapClassInst.heap32[r4 + numDefine4] = heapClassInst.heap32[r8 + numDefine5];
    heapClassInst.heap32[r4 + numDefine5] = heapClassInst.heap32[r8 + numDefine6];
    heapClassInst.heap32[r4 + numDefine6] = heapClassInst.heap32[r8 + numDefine7];
    heapClassInst.heap32[r4 + numDefine7] = heapClassInst.heap32[r8 + numDefine8];
    heapClassInst.heap32[r4 + numDefine8] = heapClassInst.heap32[r8 + numDefine9];
    heapClassInst.heap32[r4 + numDefine9] = heapClassInst.heap32[r8 + numDefine10];
    heapClassInst.heap32[r4 + numDefine10] = heapClassInst.heap32[r8 + numDefine11];
    heapClassInst.heap32[r4 + numDefine11] = heapClassInst.heap32[r8 + numDefine12];
    heapClassInst.heap32[r4 + numDefine12] = heapClassInst.heap32[r8 + numDefine13];
    heapClassInst.heap32[r4 + numDefine13] = heapClassInst.heap32[r8 + numDefine14];
    heapClassInst.heap32[r4 + numDefine14] = heapClassInst.heap32[r8 + numDefine15];
    heapClassInst.heap32[r4 + numDefine15] = heapClassInst.heap32[r8 + numDefine16];
    heapClassInst.heap32[r4 + numDefine16] = heapClassInst.heap32[r2 + 1];
    heapClassInst.heap32[r4 + numDefine17] = heapClassInst.heap32[r2 + numDefine2];
    heapClassInst.heap32[r4 + numDefine18] = heapClassInst.heap32[r2 + numDefine3];
    heapClassInst.heap32[r4 + numDefine19] = heapClassInst.heap32[r2 + numDefine4];
    heapClassInst.heap32[r4 + numDefine20] = heapClassInst.heap32[r2 + numDefine5];
    heapClassInst.heap32[r4 + numDefine21] = heapClassInst.heap32[r2 + numDefine6];
    heapClassInst.heap32[r4 + numDefine22] = heapClassInst.heap32[r2 + numDefine7];
    heapClassInst.heap32[r4 + numDefine23] = heapClassInst.heap32[r2 + numDefine8];
    heapClassInst.heap32[r4 + numDefine24] = heapClassInst.heap32[r2 + numDefine9];
    heapClassInst.heap32[r4 + numDefine25] = heapClassInst.heap32[r2 + numDefine10];
    heapClassInst.heap32[r4 + numDefine26] = heapClassInst.heap32[r2 + numDefine11];
    heapClassInst.heap32[r4 + numDefine27] = heapClassInst.heap32[r2 + numDefine12];
    heapClassInst.heap32[r4 + numDefine28] = heapClassInst.heap32[r2 + numDefine13];
    heapClassInst.heap32[r4 + numDefine29] = heapClassInst.heap32[r2 + numDefine14];
    heapClassInst.heap32[r4 + numDefine30] = heapClassInst.heap32[r2 + numDefine15];
    heapClassInst.heap32[r4 + numDefine31] = heapClassInst.heap32[r2 + numDefine16];
    r16 = heapClassInst.heap32[r5 + numDefine5];
    heapClassInst.heap32[g0] = r15;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = r6;
    heapClassInst.heap32[g0 + numDefine3] = r16;
    heapClassInst.heap32[g0 + numDefine4] = 0;
    zn17btGjkPairDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(i7);
    r16 = heapClassInst.heap32[r1 + numDefine7];
    repeat63: do {
      if (!(r16 === 0)) {
        r16 = heapClassInst.heap32[r7 + 1];
        r16 = r16 >> numDefine2;
        r16 = heapClassInst.heap32[r16 + numDefine279];
        r17 = heapClassInst.heap32[r1 + numDefine8];
        if (!(r16 >= r17)) {
          f0 = heapClassInst.heapFloat[r12 + 1];
          f1 = heapClassInst.heapFloat[r12 + numDefine2];
          f2 = heapClassInst.heapFloat[r12 + numDefine3];
          f0 = f0 * f0;
          f1 = f1 * f1;
          f0 = f0 + f1;
          f1 = f2 * f2;
          f0 = f0 + f1;
          heapClassInst.heapFloat[g0] = f0;
          sqrtf(i7);
          f1 = 1;
          heapClassInst.heapFloat[fp + numDefineNeg169] = f1;
          f2 = heapClassInst.heapFloat[r12 + numDefine3];
          f0 = f1 / commonVariable.fg0;
          f1 = heapClassInst.heapFloat[r12 + numDefine2];
          f3 = heapClassInst.heapFloat[r12 + 1];
          f2 = f2 * f0;
          heapClassInst.heapFloat[fp + numDefineNeg171] = f2;
          f1 = f1 * f0;
          heapClassInst.heapFloat[fp + numDefineNeg170] = f1;
          f0 = f3 * f0;
          heapClassInst.heapFloat[fp + numDefineNeg174] = f0;
          f0 = 0;
          heapClassInst.heapFloat[fp + numDefineNeg175] = f0;
          if (f2 < f0) {
            f0 = f2;
            f0 = -f0;
          } else {
            f0 = heapClassInst.heapFloat[fp + numDefineNeg171];
          }
          f1 = numDefineFloat742;
          if (f0 <= f1) {
            f0 = heapClassInst.heapFloat[fp + numDefineNeg174];
            f1 = f0 * f0;
            f2 = heapClassInst.heapFloat[fp + numDefineNeg170];
            f3 = f2 * f2;
            f1 = f1 + f3;
            heapClassInst.heapFloat[g0] = f1;
            sqrtf(i7);
            f3 = heapClassInst.heapFloat[fp + numDefineNeg169];
            f1 = f3 / commonVariable.fg0;
            f2 = -f2;
            f2 = f1 * f2;
            heapClassInst.heapFloat[fp + numDefineNeg173] = f2;
            f0 = f0 * f1;
            heapClassInst.heapFloat[fp + numDefineNeg172] = f0;
          } else {
            f0 = heapClassInst.heapFloat[fp + numDefineNeg170];
            f1 = f0 * f0;
            f2 = heapClassInst.heapFloat[fp + numDefineNeg171];
            f3 = f2 * f2;
            f1 = f1 + f3;
            heapClassInst.heapFloat[g0] = f1;
            sqrtf(i7);
            f3 = heapClassInst.heapFloat[fp + numDefineNeg169];
            f1 = f3 / commonVariable.fg0;
            f2 = -f2;
            f2 = f1 * f2;
            heapClassInst.heapFloat[fp + numDefineNeg172] = f2;
            f0 = f0 * f1;
            heapClassInst.heapFloat[fp + numDefineNeg175] = f0;
            f0 = 0;
            heapClassInst.heapFloat[fp + numDefineNeg173] = f0;
          }
          r11 = heapClassInst.heap32[r11];
          r11 = r11 >> numDefine2;
          r11 = heapClassInst.heap32[r11 + numDefine4];
          heapClassInst.heap32[g0] = r9;
          functionTable[r11 >> numDefine2](i7);
          f0 = commonVariable.fg0;
          heapClassInst.heapFloat[fp + numDefineNeg194] = f0;
          r9 = heapClassInst.heap32[r13];
          r9 = r9 >> numDefine2;
          r9 = heapClassInst.heap32[r9 + numDefine4];
          heapClassInst.heap32[g0] = r10;
          functionTable[r9 >> numDefine2](i7);
          f1 = commonVariable.fg0;
          heapClassInst.heapFloat[fp + numDefineNeg195] = f1;

          r9 = f0 < f1 ? 1 : 0;
          f2 = numDefineFloat064;
          f3 = f0 < f1 ? f0 : f1;
          r9 = r9 & 1;
          f2 = f2 / f3;
          if (f0 >= f1) {
            f0 = heapClassInst.heapFloat[r4 + numDefine16];
            heapClassInst.heapFloat[fp + numDefineNeg176] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine17];
            heapClassInst.heapFloat[fp + numDefineNeg177] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine18];
            heapClassInst.heapFloat[fp + numDefineNeg178] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine19];
            heapClassInst.heapFloat[fp + numDefineNeg179] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine20];
            heapClassInst.heapFloat[fp + numDefineNeg180] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine21];
            heapClassInst.heapFloat[fp + numDefineNeg181] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine22];
            heapClassInst.heapFloat[fp + numDefineNeg182] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine23];
            heapClassInst.heapFloat[fp + numDefineNeg183] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine24];
            heapClassInst.heapFloat[fp + numDefineNeg184] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine25];
            heapClassInst.heapFloat[fp + numDefineNeg185] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine26];
            heapClassInst.heapFloat[fp + numDefineNeg186] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine27];
            heapClassInst.heapFloat[fp + numDefineNeg187] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine28];
            heapClassInst.heapFloat[fp + numDefineNeg188] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine29];
            heapClassInst.heapFloat[fp + numDefineNeg189] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine30];
            heapClassInst.heapFloat[fp + numDefineNeg190] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine31];
            heapClassInst.heapFloat[fp + numDefineNeg191] = f0;
          } else {
            f0 = heapClassInst.heapFloat[fp + numDefineNeg42];
            heapClassInst.heapFloat[fp + numDefineNeg176] = f0;
            f0 = heapClassInst.heapFloat[r4 + 1];
            heapClassInst.heapFloat[fp + numDefineNeg177] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine2];
            heapClassInst.heapFloat[fp + numDefineNeg178] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine3];
            heapClassInst.heapFloat[fp + numDefineNeg179] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine4];
            heapClassInst.heapFloat[fp + numDefineNeg180] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine5];
            heapClassInst.heapFloat[fp + numDefineNeg181] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine6];
            heapClassInst.heapFloat[fp + numDefineNeg182] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine7];
            heapClassInst.heapFloat[fp + numDefineNeg183] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine8];
            heapClassInst.heapFloat[fp + numDefineNeg184] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine9];
            heapClassInst.heapFloat[fp + numDefineNeg185] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine10];
            heapClassInst.heapFloat[fp + numDefineNeg186] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine11];
            heapClassInst.heapFloat[fp + numDefineNeg187] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine12];
            heapClassInst.heapFloat[fp + numDefineNeg188] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine13];
            heapClassInst.heapFloat[fp + numDefineNeg189] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine14];
            heapClassInst.heapFloat[fp + numDefineNeg190] = f0;
            f0 = heapClassInst.heapFloat[r4 + numDefine15];
            heapClassInst.heapFloat[fp + numDefineNeg191] = f0;
          }
          f0 = heapClassInst.heapFloat[fp + numDefineNeg173];
          f0 = f0 * f0;
          f1 = heapClassInst.heapFloat[fp + numDefineNeg172];
          f1 = f1 * f1;
          f3 = numDefineFloat05;
          heapClassInst.heapFloat[fp + numDefineNeg193] = f3;
          f4 = heapClassInst.heapFloat[fp + numDefineNeg174];
          f4 = f4 * f4;
          f5 = heapClassInst.heapFloat[fp + numDefineNeg170];
          f5 = f5 * f5;
          f0 = f0 + f1;
          f1 = heapClassInst.heapFloat[fp + numDefineNeg175];
          f1 = f1 * f1;
          f6 = numDefineFloat366;
          f7 = numDefineFloat183;
          f3 = f2 * f3;
          f4 = f4 + f5;
          f5 = heapClassInst.heapFloat[fp + numDefineNeg171];
          f5 = f5 * f5;
          f0 = f0 + f1;
          heapClassInst.heapFloat[fp + numDefineNeg196] = f0;
          f0 = f2 > f6 ? f7 : f3;
          heapClassInst.heapFloat[fp + numDefineNeg197] = f0;
          f0 = f4 + f5;
          heapClassInst.heapFloat[fp + numDefineNeg192] = f0;
          repeat78: while (true) {
            r10 = heapClassInst.heap32[r1 + numDefine7];
            if (r10 > r14) {
              f0 = numDefineFloat1257;
              f1 = heapClassInst.heapFloat[fp + numDefineNeg196];
              if (!(f1 <= f0)) {
                f0 = f1;
                heapClassInst.heapFloat[g0] = f0;
                sqrtf(i7);
                f0 = commonVariable.fg0;
                f1 = 0;
                if (f0 !== f1) {
                  f2 = heapClassInst.heapFloat[fp + numDefineNeg197];
                  heapClassInst.heapFloat[g0] = f2;
                  sinf(i7);
                  f3 = commonVariable.fg0;
                  heapClassInst.heapFloat[g0] = f2;
                  cosf(i7);
                  f2 = commonVariable.fg0;
                  r10 = heapClassInst.heap32[r1 + numDefine7];
                  f4 = heapClassInst.heapFloat[fp + numDefineNeg192];
                  heapClassInst.heapFloat[g0] = f4;
                  sqrtf(i7);
                  f4 = commonVariable.fg0;
                  if (f4 !== f1) {
                    f0 = f3 / f0;
                    f3 = heapClassInst.heapFloat[fp + numDefineNeg175];
                    f3 = f3 * f0;
                    f5 = heapClassInst.heapFloat[fp + numDefineNeg172];
                    f5 = f5 * f0;
                    f6 = heapClassInst.heapFloat[fp + numDefineNeg173];
                    f0 = f6 * f0;
                    f6 = numDefineFloat265;
                    f7 = r10;
                    f8 = r14;
                    f6 = f6 / f7;
                    f6 = f8 * f6;
                    f7 = heapClassInst.heapFloat[fp + numDefineNeg193];
                    f6 = f6 * f7;
                    heapClassInst.heapFloat[g0] = f6;
                    sinf(i7);
                    heapClassInst.heapFloat[g0] = f6;
                    f4 = commonVariable.fg0 / f4;
                    f6 = heapClassInst.heapFloat[fp + numDefineNeg171];
                    f6 = f6 * f4;
                    f7 = heapClassInst.heapFloat[fp + numDefineNeg170];
                    f7 = f7 * f4;
                    f8 = heapClassInst.heapFloat[fp + numDefineNeg174];
                    f4 = f8 * f4;
                    cosf(i7);
                    f8 = commonVariable.fg0;
                    f10 = heapClassInst.heapFloat[fp + numDefineNeg195];
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg194];
                    if (f9 >= f10) {
                      f9 = heapClassInst.heapFloat[r8 + 1];
                      heapClassInst.heapFloat[fp + numDefineNeg155] = f9;
                      heapClassInst.heapFloat[fp + numDefineNeg42] = f9;
                      f9 = heapClassInst.heapFloat[r8 + numDefine2];
                      heapClassInst.heapFloat[fp + numDefineNeg156] = f9;
                      heapClassInst.heapFloat[r4 + 1] = f9;
                      f9 = heapClassInst.heapFloat[r8 + numDefine3];
                      heapClassInst.heapFloat[fp + numDefineNeg157] = f9;
                      heapClassInst.heapFloat[r4 + numDefine2] = f9;
                      f9 = heapClassInst.heapFloat[r8 + numDefine4];
                      heapClassInst.heapFloat[fp + numDefineNeg163] = f9;
                      heapClassInst.heapFloat[r4 + numDefine3] = f9;
                      f9 = heapClassInst.heapFloat[r8 + numDefine5];
                      heapClassInst.heapFloat[fp + numDefineNeg158] = f9;
                      heapClassInst.heapFloat[r4 + numDefine4] = f9;
                      f9 = heapClassInst.heapFloat[r8 + numDefine6];
                      heapClassInst.heapFloat[fp + numDefineNeg159] = f9;
                      heapClassInst.heapFloat[r4 + numDefine5] = f9;
                      f9 = heapClassInst.heapFloat[r8 + numDefine7];
                      heapClassInst.heapFloat[fp + numDefineNeg160] = f9;
                      heapClassInst.heapFloat[r4 + numDefine6] = f9;
                      f9 = heapClassInst.heapFloat[r8 + numDefine8];
                      heapClassInst.heapFloat[fp + numDefineNeg162] = f9;
                      heapClassInst.heapFloat[r4 + numDefine7] = f9;
                      f9 = heapClassInst.heapFloat[r8 + numDefine9];
                      heapClassInst.heapFloat[fp + numDefineNeg161] = f9;
                      f10 = f8 * f2;
                      f11 = f0 * f4;
                      f12 = f8 * f0;
                      f13 = f2 * f4;
                      f14 = f8 * f5;
                      f15 = f2 * f7;
                      heapClassInst.heapFloat[r4 + numDefine8] = f9;
                      f9 = f10 + f11;
                      f10 = f5 * f7;
                      f11 = f8 * f3;
                      f2 = f2 * f6;
                      f12 = f12 - f13;
                      f13 = f3 * f7;
                      f14 = f14 - f15;
                      f15 = f0 * f6;
                      f16 = heapClassInst.heapFloat[r8 + numDefine10];
                      heapClassInst.heapFloat[fp + numDefineNeg164] = f16;
                      f9 = f9 + f10;
                      f10 = f3 * f6;
                      f2 = f11 - f2;
                      f11 = f5 * f4;
                      f12 = f12 - f13;
                      f5 = f5 * f6;
                      f13 = f14 - f15;
                      f3 = f3 * f4;
                      f9 = f9 + f10;
                      f5 = f12 + f5;
                      f3 = f13 + f3;
                      heapClassInst.heapFloat[r4 + numDefine9] = f16;
                      f2 = f2 - f11;
                      f0 = f0 * f7;
                      f0 = f2 + f0;
                      f2 = heapClassInst.heapFloat[r8 + numDefine11];
                      heapClassInst.heapFloat[fp + numDefineNeg166] = f2;
                      f10 = f9 * f7;
                      f11 = f3 * f8;
                      f12 = f9 * f4;
                      f13 = f5 * f8;
                      heapClassInst.heapFloat[r4 + numDefine10] = f2;
                      f2 = f10 + f11;
                      f10 = f0 * f4;
                      f11 = f12 + f13;
                      f12 = f3 * f6;
                      f13 = f9 * f6;
                      f14 = f0 * f8;
                      f17 = heapClassInst.heapFloat[r8 + numDefine12];
                      f8 = f9 * f8;
                      f9 = f5 * f4;
                      f2 = f2 + f10;
                      f10 = f5 * f6;
                      f11 = f11 + f12;
                      f12 = f0 * f7;
                      f13 = f13 + f14;
                      f5 = f5 * f7;
                      f10 = f2 - f10;
                      f2 = f11 - f12;
                      heapClassInst.heapFloat[r4 + numDefine11] = f17;
                      f8 = f8 - f9;
                      f7 = f3 * f7;
                      f5 = f13 + f5;
                      f3 = f3 * f4;
                      f4 = heapClassInst.heapFloat[r8 + numDefine13];
                      heapClassInst.heapFloat[fp + numDefineNeg165] = f4;
                      f3 = f5 - f3;
                      f5 = f8 - f7;
                      f0 = f0 * f6;
                      f6 = f2 * f2;
                      f7 = f10 * f10;
                      f5 = f5 - f0;
                      heapClassInst.heapFloat[r4 + numDefine12] = f4;
                      f0 = f6 + f7;
                      f4 = f3 * f3;
                      f6 = heapClassInst.heapFloat[r8 + numDefine14];
                      heapClassInst.heapFloat[fp + numDefineNeg167] = f6;
                      f0 = f0 + f4;
                      f4 = f5 * f5;
                      heapClassInst.heapFloat[r4 + numDefine13] = f6;
                      f6 = numDefine2;
                      f0 = f0 + f4;
                      f0 = f6 / f0;
                      f4 = heapClassInst.heapFloat[r8 + numDefine15];
                      heapClassInst.heapFloat[fp + numDefineNeg168] = f4;
                      f6 = f3 * f0;
                      f7 = f10 * f0;
                      heapClassInst.heapFloat[r4 + numDefine14] = f4;
                      f16 = heapClassInst.heapFloat[r8 + numDefine16];
                      f4 = f10 * f7;
                      f3 = f3 * f6;
                      f8 = f4 + f3;
                      f9 = f2 * f7;
                      f11 = f5 * f6;
                      heapClassInst.heapFloat[r4 + numDefine15] = f16;
                      f12 = heapClassInst.heapFloat[fp + numDefineNeg169];
                      f8 = f12 - f8;
                      f13 = heapClassInst.heapFloat[r2 + 1];
                      f14 = f9 - f11;
                      f15 = heapClassInst.heapFloat[r2 + numDefine5];
                      f18 = f2 * f6;
                      f7 = f5 * f7;
                      f19 = f2 * f0;
                      f20 = heapClassInst.heapFloat[r2 + numDefine2];
                      f21 = heapClassInst.heapFloat[r2 + numDefine6];
                      f0 = f13 * f8;
                      f22 = f15 * f14;
                      f23 = f18 + f7;
                      f24 = heapClassInst.heapFloat[r2 + numDefine9];
                      f25 = f2 * f19;
                      f26 = heapClassInst.heapFloat[r2 + numDefine3];
                      f27 = heapClassInst.heapFloat[r2 + numDefine7];
                      f28 = heapClassInst.heapFloat[r2 + numDefine11];
                      f29 = heapClassInst.heapFloat[r2 + numDefine10];
                      f2 = f20 * f8;
                      f30 = f21 * f14;
                      f0 = f0 + f22;
                      f22 = f24 * f23;
                      f3 = f25 + f3;
                      f0 = f0 + f22;
                      f8 = f26 * f8;
                      f14 = f27 * f14;
                      f2 = f2 + f30;
                      f22 = f29 * f23;
                      f9 = f9 + f11;
                      f11 = f12 - f3;
                      f2 = f2 + f22;
                      heapClassInst.heapFloat[r4 + numDefine16] = f0;
                      f6 = f10 * f6;
                      f10 = f5 * f19;
                      f3 = f8 + f14;
                      f5 = f28 * f23;
                      f8 = f6 - f10;
                      f3 = f3 + f5;
                      heapClassInst.heapFloat[r4 + numDefine17] = f2;
                      f5 = f13 * f9;
                      f14 = f15 * f11;
                      heapClassInst.heapFloat[r4 + numDefine18] = f3;
                      f19 = f20 * f9;
                      f22 = f21 * f11;
                      f5 = f5 + f14;
                      f14 = f24 * f8;
                      f5 = f5 + f14;
                      heapClassInst.heap32[r4 + numDefine19] = 0;
                      f9 = f26 * f9;
                      f11 = f27 * f11;
                      f14 = f19 + f22;
                      f19 = f29 * f8;
                      f18 = f18 - f7;
                      f10 = f6 + f10;
                      f4 = f25 + f4;
                      f6 = f14 + f19;
                      heapClassInst.heapFloat[r4 + numDefine20] = f5;
                      f7 = f9 + f11;
                      f8 = f28 * f8;
                      f4 = f12 - f4;
                      f7 = f7 + f8;
                      heapClassInst.heapFloat[r4 + numDefine21] = f6;
                      f8 = f13 * f18;
                      f9 = f15 * f10;
                      heapClassInst.heapFloat[r4 + numDefine22] = f7;
                      f11 = f20 * f18;
                      f12 = f21 * f10;
                      f8 = f8 + f9;
                      f9 = f24 * f4;
                      f9 = f8 + f9;
                      heapClassInst.heap32[r4 + numDefine23] = 0;
                      f8 = f26 * f18;
                      f13 = f27 * f10;
                      f10 = f11 + f12;
                      f11 = f29 * f4;
                      f10 = f10 + f11;
                      heapClassInst.heapFloat[r4 + numDefine24] = f9;
                      f8 = f8 + f13;
                      f4 = f28 * f4;
                      f11 = f8 + f4;
                      heapClassInst.heapFloat[r4 + numDefine25] = f10;
                      heapClassInst.heapFloat[r4 + numDefine26] = f11;
                      heapClassInst.heap32[r4 + numDefine27] = 0;
                      f12 = heapClassInst.heapFloat[r4 + numDefine28];
                      f13 = heapClassInst.heapFloat[r4 + numDefine29];
                      f14 = heapClassInst.heapFloat[r4 + numDefine30];
                      f15 = heapClassInst.heapFloat[r4 + numDefine31];
                      f8 = f1;
                      f4 = f1;
                    } else {
                      f1 = f8 * f2;
                      f9 = f0 * f4;
                      f10 = f8 * f0;
                      f11 = f2 * f4;
                      f12 = f8 * f5;
                      f13 = f2 * f7;
                      f1 = f1 + f9;
                      f9 = f5 * f7;
                      f14 = f8 * f3;
                      f2 = f2 * f6;
                      f10 = f10 - f11;
                      f11 = f3 * f7;
                      f12 = f12 - f13;
                      f13 = f0 * f6;
                      f1 = f1 + f9;
                      f9 = f3 * f6;
                      f2 = f14 - f2;
                      f14 = f5 * f4;
                      f10 = f10 - f11;
                      f5 = f5 * f6;
                      f11 = f12 - f13;
                      f3 = f3 * f4;
                      f1 = f1 + f9;
                      f5 = f10 + f5;
                      f3 = f11 + f3;
                      f2 = f2 - f14;
                      f0 = f0 * f7;
                      f0 = f2 + f0;
                      f2 = f1 * f7;
                      f9 = f3 * f8;
                      f10 = f1 * f4;
                      f11 = f5 * f8;
                      f2 = f2 + f9;
                      f9 = f0 * f4;
                      f10 = f10 + f11;
                      f11 = f3 * f6;
                      f12 = f1 * f6;
                      f13 = f0 * f8;
                      f1 = f1 * f8;
                      f8 = f5 * f4;
                      f2 = f2 + f9;
                      f9 = f5 * f6;
                      f10 = f10 + f11;
                      f11 = f0 * f7;
                      f12 = f12 + f13;
                      f5 = f5 * f7;
                      f2 = f2 - f9;
                      f9 = f10 - f11;
                      f1 = f1 - f8;
                      f7 = f3 * f7;
                      f5 = f12 + f5;
                      f3 = f3 * f4;
                      f3 = f5 - f3;
                      f1 = f1 - f7;
                      f0 = f0 * f6;
                      f4 = f9 * f9;
                      f5 = f2 * f2;
                      f0 = f1 - f0;
                      f1 = f4 + f5;
                      f4 = f3 * f3;
                      f1 = f1 + f4;
                      f4 = f0 * f0;
                      f5 = numDefine2;
                      f1 = f1 + f4;
                      f1 = f5 / f1;
                      f4 = f3 * f1;
                      f5 = f2 * f1;
                      f6 = f2 * f5;
                      f3 = f3 * f4;
                      f7 = f6 + f3;
                      f8 = f9 * f5;
                      f10 = f0 * f4;
                      f11 = heapClassInst.heapFloat[fp + numDefineNeg169];
                      f7 = f11 - f7;
                      f12 = heapClassInst.heapFloat[r8 + 1];
                      f13 = f8 - f10;
                      f14 = heapClassInst.heapFloat[r8 + numDefine5];
                      f15 = f9 * f4;
                      f5 = f0 * f5;
                      f1 = f9 * f1;
                      f16 = heapClassInst.heapFloat[r8 + numDefine2];
                      f17 = heapClassInst.heapFloat[r8 + numDefine6];
                      f18 = f12 * f7;
                      f19 = f14 * f13;
                      f20 = f15 + f5;
                      f21 = heapClassInst.heapFloat[r8 + numDefine9];
                      f9 = f9 * f1;
                      f22 = heapClassInst.heapFloat[r8 + numDefine3];
                      f23 = heapClassInst.heapFloat[r8 + numDefine7];
                      f24 = heapClassInst.heapFloat[r8 + numDefine11];
                      f25 = heapClassInst.heapFloat[r8 + numDefine10];
                      f26 = f16 * f7;
                      f27 = f17 * f13;
                      f18 = f18 + f19;
                      f19 = f21 * f20;
                      f3 = f9 + f3;
                      f18 = f18 + f19;
                      heapClassInst.heapFloat[fp + numDefineNeg155] = f18;
                      f7 = f22 * f7;
                      f13 = f23 * f13;
                      f19 = f26 + f27;
                      f26 = f25 * f20;
                      f8 = f8 + f10;
                      f3 = f11 - f3;
                      f10 = f19 + f26;
                      heapClassInst.heapFloat[fp + numDefineNeg156] = f10;
                      heapClassInst.heapFloat[fp + numDefineNeg42] = f18;
                      f2 = f2 * f4;
                      f0 = f0 * f1;
                      f1 = f7 + f13;
                      f4 = f24 * f20;
                      f7 = f2 - f0;
                      f1 = f1 + f4;
                      heapClassInst.heapFloat[fp + numDefineNeg157] = f1;
                      heapClassInst.heapFloat[r4 + 1] = f10;
                      f4 = f12 * f8;
                      f10 = f14 * f3;
                      heapClassInst.heapFloat[r4 + numDefine2] = f1;
                      f1 = f16 * f8;
                      f13 = f17 * f3;
                      f4 = f4 + f10;
                      f10 = f21 * f7;
                      f4 = f4 + f10;
                      heapClassInst.heapFloat[fp + numDefineNeg158] = f4;
                      heapClassInst.heap32[r4 + numDefine3] = 0;
                      f8 = f22 * f8;
                      f3 = f23 * f3;
                      f1 = f1 + f13;
                      f10 = f25 * f7;
                      f5 = f15 - f5;
                      f0 = f2 + f0;
                      f2 = f9 + f6;
                      f1 = f1 + f10;
                      heapClassInst.heapFloat[fp + numDefineNeg159] = f1;
                      heapClassInst.heapFloat[r4 + numDefine4] = f4;
                      f3 = f8 + f3;
                      f4 = f24 * f7;
                      f2 = f11 - f2;
                      f3 = f3 + f4;
                      heapClassInst.heapFloat[fp + numDefineNeg160] = f3;
                      heapClassInst.heapFloat[r4 + numDefine5] = f1;
                      f1 = f12 * f5;
                      f4 = f14 * f0;
                      heapClassInst.heapFloat[r4 + numDefine6] = f3;
                      f3 = f16 * f5;
                      f6 = f17 * f0;
                      f1 = f1 + f4;
                      f4 = f21 * f2;
                      f1 = f1 + f4;
                      heapClassInst.heapFloat[fp + numDefineNeg161] = f1;
                      heapClassInst.heap32[r4 + numDefine7] = 0;
                      f4 = f22 * f5;
                      f0 = f23 * f0;
                      f3 = f3 + f6;
                      f5 = f25 * f2;
                      f3 = f3 + f5;
                      heapClassInst.heapFloat[fp + numDefineNeg164] = f3;
                      heapClassInst.heapFloat[r4 + numDefine8] = f1;
                      f0 = f4 + f0;
                      f1 = f24 * f2;
                      f0 = f0 + f1;
                      heapClassInst.heapFloat[fp + numDefineNeg166] = f0;
                      heapClassInst.heapFloat[r4 + numDefine9] = f3;
                      heapClassInst.heapFloat[r4 + numDefine10] = f0;
                      heapClassInst.heap32[r4 + numDefine11] = 0;
                      f0 = heapClassInst.heapFloat[r2 + 1];
                      heapClassInst.heapFloat[r4 + numDefine16] = f0;
                      f2 = heapClassInst.heapFloat[r2 + numDefine2];
                      heapClassInst.heapFloat[r4 + numDefine17] = f2;
                      f3 = heapClassInst.heapFloat[r2 + numDefine3];
                      heapClassInst.heapFloat[r4 + numDefine18] = f3;
                      f4 = heapClassInst.heapFloat[r2 + numDefine4];
                      heapClassInst.heapFloat[r4 + numDefine19] = f4;
                      f5 = heapClassInst.heapFloat[r2 + numDefine5];
                      heapClassInst.heapFloat[r4 + numDefine20] = f5;
                      f6 = heapClassInst.heapFloat[r2 + numDefine6];
                      heapClassInst.heapFloat[r4 + numDefine21] = f6;
                      f7 = heapClassInst.heapFloat[r2 + numDefine7];
                      heapClassInst.heapFloat[r4 + numDefine22] = f7;
                      f8 = heapClassInst.heapFloat[r2 + numDefine8];
                      heapClassInst.heapFloat[r4 + numDefine23] = f8;
                      f9 = heapClassInst.heapFloat[r2 + numDefine9];
                      heapClassInst.heapFloat[r4 + numDefine24] = f9;
                      f10 = heapClassInst.heapFloat[r2 + numDefine10];
                      heapClassInst.heapFloat[r4 + numDefine25] = f10;
                      f11 = heapClassInst.heapFloat[r2 + numDefine11];
                      heapClassInst.heapFloat[r4 + numDefine26] = f11;
                      f1 = heapClassInst.heapFloat[r2 + numDefine12];
                      heapClassInst.heapFloat[r4 + numDefine27] = f1;
                      f12 = heapClassInst.heapFloat[r2 + numDefine13];
                      heapClassInst.heapFloat[r4 + numDefine28] = f12;
                      f13 = heapClassInst.heapFloat[r2 + numDefine14];
                      heapClassInst.heapFloat[r4 + numDefine29] = f13;
                      f14 = heapClassInst.heapFloat[r2 + numDefine15];
                      heapClassInst.heapFloat[r4 + numDefine30] = f14;
                      f15 = heapClassInst.heapFloat[r2 + numDefine16];
                      heapClassInst.heapFloat[r4 + numDefine31] = f15;
                      f16 = heapClassInst.heapFloat[r4 + numDefine12];
                      heapClassInst.heapFloat[fp + numDefineNeg165] = f16;
                      f16 = heapClassInst.heapFloat[r4 + numDefine13];
                      heapClassInst.heapFloat[fp + numDefineNeg167] = f16;
                      f16 = heapClassInst.heapFloat[r4 + numDefine14];
                      heapClassInst.heapFloat[fp + numDefineNeg168] = f16;
                      f16 = heapClassInst.heapFloat[r4 + numDefine15];
                      f17 = 0;
                      heapClassInst.heapFloat[fp + numDefineNeg162] = f17;
                      heapClassInst.heapFloat[fp + numDefineNeg163] = f17;
                    }
                    r10 = ztv24btPerturbedContactResult;
                    r11 = sp + numDefineNeg616;
                    r12 = heapClassInst.heap32[r5 + numDefine5];
                    r10 = (r10 + numDefine8) | 0;
                    r13 = r11 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg154] = r10;
                    heapClassInst.heap32[r13 + numDefine40] = r6;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg155];
                    heapClassInst.heapFloat[r13 + numDefine41] = f18;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg156];
                    heapClassInst.heapFloat[r13 + numDefine42] = f18;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg157];
                    heapClassInst.heapFloat[r13 + numDefine43] = f18;
                    f22 = heapClassInst.heapFloat[fp + numDefineNeg163];
                    heapClassInst.heapFloat[r13 + numDefine44] = f22;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg158];
                    heapClassInst.heapFloat[r13 + numDefine45] = f18;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg159];
                    heapClassInst.heapFloat[r13 + numDefine46] = f18;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg160];
                    heapClassInst.heapFloat[r13 + numDefine47] = f18;
                    f22 = heapClassInst.heapFloat[fp + numDefineNeg162];
                    heapClassInst.heapFloat[r13 + numDefine48] = f22;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg161];
                    heapClassInst.heapFloat[r13 + numDefine49] = f18;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg164];
                    heapClassInst.heapFloat[r13 + numDefine50] = f18;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg166];
                    heapClassInst.heapFloat[r13 + numDefine51] = f18;
                    heapClassInst.heapFloat[r13 + numDefine52] = f17;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg165];
                    heapClassInst.heapFloat[r13 + numDefine53] = f17;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg167];
                    heapClassInst.heapFloat[r13 + numDefine54] = f17;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg168];
                    heapClassInst.heapFloat[r13 + numDefine55] = f17;
                    heapClassInst.heapFloat[r13 + numDefine56] = f16;
                    heapClassInst.heapFloat[r13 + numDefine57] = f0;
                    heapClassInst.heapFloat[r13 + numDefine58] = f2;
                    heapClassInst.heapFloat[r13 + numDefine59] = f3;
                    heapClassInst.heapFloat[r13 + numDefine60] = f4;
                    heapClassInst.heapFloat[r13 + numDefine61] = f5;
                    heapClassInst.heapFloat[r13 + numDefine62] = f6;
                    heapClassInst.heapFloat[r13 + numDefine63] = f7;
                    heapClassInst.heapFloat[r13 + numDefine64] = f8;
                    heapClassInst.heapFloat[r13 + numDefine65] = f9;
                    heapClassInst.heapFloat[r13 + numDefine66] = f10;
                    heapClassInst.heapFloat[r13 + numDefine67] = f11;
                    heapClassInst.heapFloat[r13 + numDefine68] = f1;
                    heapClassInst.heapFloat[r13 + numDefine69] = f12;
                    heapClassInst.heapFloat[r13 + numDefine70] = f13;
                    heapClassInst.heapFloat[r13 + numDefine71] = f14;
                    heapClassInst.heapFloat[r13 + numDefine72] = f15;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg176];
                    heapClassInst.heapFloat[r13 + numDefine73] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg177];
                    heapClassInst.heapFloat[r13 + numDefine74] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg178];
                    heapClassInst.heapFloat[r13 + numDefine75] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg179];
                    heapClassInst.heapFloat[r13 + numDefine76] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg180];
                    heapClassInst.heapFloat[r13 + numDefine77] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg181];
                    heapClassInst.heapFloat[r13 + numDefine78] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg182];
                    heapClassInst.heapFloat[r13 + numDefine79] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg183];
                    heapClassInst.heapFloat[r13 + numDefine80] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg184];
                    heapClassInst.heapFloat[r13 + numDefine81] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg185];
                    heapClassInst.heapFloat[r13 + numDefine82] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg186];
                    heapClassInst.heapFloat[r13 + numDefine83] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg187];
                    heapClassInst.heapFloat[r13 + numDefine84] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg188];
                    heapClassInst.heapFloat[r13 + numDefine85] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg189];
                    heapClassInst.heapFloat[r13 + numDefine86] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg190];
                    heapClassInst.heapFloat[r13 + numDefine87] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                    heapClassInst.heapFloat[r13 + numDefine88] = f0;
                    heapClassInst.heap8[sp + numDefineNeg260] = r9;
                    heapClassInst.heap32[r13 + numDefine90] = r12;
                    heapClassInst.heap32[g0] = r15;
                    heapClassInst.heap32[g0 + 1] = r3;
                    heapClassInst.heap32[g0 + numDefine2] = r11;
                    heapClassInst.heap32[g0 + numDefine3] = r12;
                    heapClassInst.heap32[g0 + numDefine4] = 0;
                    zn17btGjkPairDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(i7);
                  } else {
                    break repeat78;
                  }
                } else {
                  break repeat78;
                }
              }
              r14 = (r14 + 1) | 0;
            } else {
              break repeat63;
            }
          }
          r0 = twoEStr115;
          r1 = twoEStr685;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r1;
          heapClassInst.heap32[g0 + numDefine2] = numDefine61;
          assertNew(i7);
        }
      }
    } while (false);
    r0 = heapClassInst.heapU8[r0 + numDefine16];
    if (r0 === 0) {
      label = numDefine44;
    } else {
      r0 = heapClassInst.heap32[r7 + 1];
      if (r0 !== 0) {
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine279];
        if (r2 === 0) {
          label = numDefine44;
        } else {
          r1 = heapClassInst.heap32[r1 + numDefine277];
          r2 = heapClassInst.heap32[r7 + numDefine34];
          if (r1 === r2) {
            label = numDefine43;
          } else {
            r1 = (r6 + numDefine72) | 0;
            r6 = (r6 + numDefine8) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r6;
            zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
            return;
          }
        }
      } else {
        r0 = twoEStr59;
        r6 = twoEStr160;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = numDefine101;
        assertNew(i7);
      }
    }
  }
  switch (label) {
    case numDefine44:
      return;
    case numDefine43:
      r1 = (r6 + numDefine8) | 0;
      r2 = (r6 + numDefine72) | 0;
      break;
    default:
      break;
  }
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
  return;
}

function zn23btConvexConvexAlgorithmD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv23btConvexConvexAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine16];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine5];
    if (!(r1 === 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      r4 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + numDefine4];
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r1;
      functionTable[r4 >> numDefine2](i7);
    }
  }
  r1 = ztv30btActivatingCollisionAlgorithm;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn23btConvexConvexAlgorithmD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv23btConvexConvexAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r0 = heapClassInst.heapU8[r0 + numDefine16];
  if (!(r0 === 0)) {
    r0 = heapClassInst.heap32[r2 + numDefine5];
    if (!(r0 === 0)) {
      r1 = heapClassInst.heap32[r2 + 1];
      r3 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine4];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      functionTable[r3 >> numDefine2](i7);
    }
  }
  r0 = ztv30btActivatingCollisionAlgorithm;
  r0 = (r0 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r0;
  return;
}

function zn31btConvexPlaneCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  f0 = 1;
  commonVariable.fg0 = f0;
  return;
}

function zn31btConvexPlaneCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine3];
  if (!(r2 === 0)) {
    r0 = heapClassInst.heapU8[r0 + numDefine8];
    if (!(r0 === 0)) {
      r0 = heapClassInst.heap32[fp + 1];
      r3 = r0 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine2];
      r5 = heapClassInst.heap32[r3 + 1];
      if (r4 === r5) {
        r6 = 1;
        r7 = r5 << 1;
        r7 = r5 === 0 ? r6 : r7;
        if (!(r4 >= r7)) {
          if (r7 !== 0) {
            r2 = gNumAlignedAllocs;
            r2 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r2];
            r8 = r7 << numDefine2;
            r4 = (r4 + 1) | 0;
            r8 = r8 | numDefine3;
            heapClassInst.heap32[r2] = r4;
            r2 = (r8 + numDefine16) | 0;
            heapClassInst.heap32[g0] = r2;
            mallocNew(i7);
            r2 = commonVariable.rg0;
            if (r2 !== 0) {
              r4 = 0;
              r8 = (r2 + numDefine4) | 0;
              r4 = (r4 - r8) | 0;
              r4 = r4 & numDefine15;
              r4 = (r2 + r4) | 0;
              r8 = (r4 + numDefine4) | 0;
              r4 = r4 >> numDefine2;
              heapClassInst.heap32[r4] = r2;
              r2 = r8;
            }
          } else {
            r2 = 0;
          }
          r4 = (r0 + numDefine12) | 0;
          if (r5 < 1) {
            r8 = r4 >> numDefine2;
            r9 = heapClassInst.heap32[r8];
          } else {
            r8 = 0;
            repeat15: while (true) {
              r9 = r4 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r10 = r8 << numDefine2;
              r11 = (r9 + r10) | 0;
              r11 = r11 >> numDefine2;
              r10 = (r2 + r10) | 0;
              r11 = heapClassInst.heap32[r11];
              r8 = (r8 + 1) | 0;
              r10 = r10 >> numDefine2;
              heapClassInst.heap32[r10] = r11;
              if (!(r5 !== r8)) {
                break repeat15;
              }
            }
            r4 = (r0 + numDefine12) | 0;
          }
          if (r9 !== 0) {
            r8 = heapClassInst.heapU8[r0 + numDefine16];
            if (r8 !== 0) {
              r5 = gNumAlignedFree;
              r5 = r5 >> numDefine2;
              r8 = heapClassInst.heap32[r5];
              r8 = (r8 + 1) | 0;
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r5] = r8;
              r5 = heapClassInst.heap32[r9 + -1];
              heapClassInst.heap32[g0] = r5;
              free(i7);
              r5 = heapClassInst.heap32[r3 + 1];
            }
            r8 = r4 >> numDefine2;
            heapClassInst.heap32[r8] = 0;
          }
          r4 = r4 >> numDefine2;
          heapClassInst.heap8[r0 + numDefine16] = r6;
          heapClassInst.heap32[r4] = r2;
          heapClassInst.heap32[r3 + numDefine2] = r7;
          r2 = heapClassInst.heap32[r1 + numDefine3];
        }
      }
      r0 = r5 << numDefine2;
      r1 = heapClassInst.heap32[r3 + numDefine3];
      r0 = (r1 + r0) | 0;
      r0 = r0 >> numDefine2;
      heapClassInst.heap32[r0] = r2;
      r0 = heapClassInst.heap32[r3 + 1];
      r0 = (r0 + 1) | 0;
      heapClassInst.heap32[r3 + 1] = r0;
    }
  }
  return;
}

function zn31btConvexPlaneCollisionAlgorithm20collideSingleContactERK12btQuaternionP17btCollisionObjectS4RK16btDispatcherInfoP16btManifoldResult(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let f29: number = 0.0;
  let f30: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg136;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0];
  f1 = heapClassInst.heapFloat[r0 + 1];
  f2 = heapClassInst.heapFloat[r0 + numDefine2];
  f3 = f0 * f0;
  f4 = f1 * f1;
  f5 = heapClassInst.heapFloat[r0 + numDefine3];
  f3 = f3 + f4;
  f4 = f2 * f2;
  f3 = f3 + f4;
  f4 = f5 * f5;
  f6 = numDefine2;
  f3 = f3 + f4;
  f3 = f6 / f3;
  r0 = heapClassInst.heap32[fp];
  f4 = f2 * f3;
  f6 = f1 * f3;
  r1 = heapClassInst.heapU8[r0 + numDefine16];
  r2 = heapClassInst.heap32[fp + numDefine3];
  r3 = heapClassInst.heap32[fp + numDefine2];
  f3 = f0 * f3;
  r4 = r1 === 0 ? r3 : r2;
  f7 = f1 * f6;
  f2 = f2 * f4;
  r4 = r4 >> numDefine2;
  f8 = f0 * f3;
  f9 = 1;
  f10 = f7 + f2;
  f11 = f0 * f6;
  f12 = f5 * f4;
  f2 = f8 + f2;
  f10 = f9 - f10;
  f13 = heapClassInst.heapFloat[r4 + 1];
  heapClassInst.heapFloat[fp + numDefineNeg17] = f13;
  f13 = heapClassInst.heapFloat[r4 + numDefine5];
  heapClassInst.heapFloat[fp + numDefineNeg18] = f13;
  f14 = f11 + f12;
  f13 = heapClassInst.heapFloat[r4 + numDefine2];
  heapClassInst.heapFloat[fp + numDefineNeg19] = f13;
  f13 = heapClassInst.heapFloat[r4 + numDefine6];
  heapClassInst.heapFloat[fp + numDefineNeg20] = f13;
  f0 = f0 * f4;
  f6 = f5 * f6;
  f11 = f11 - f12;
  f2 = f9 - f2;
  f12 = heapClassInst.heapFloat[r4 + numDefine9];
  heapClassInst.heapFloat[fp + numDefineNeg24] = f12;
  f15 = heapClassInst.heapFloat[r4 + numDefine10];
  heapClassInst.heapFloat[fp + numDefineNeg25] = f15;
  r1 = r1 === 0 ? r2 : r3;
  f1 = f1 * f4;
  f3 = f5 * f3;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg17];
  f4 = f10 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg19];
  f5 = f14 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg18];
  f16 = f10 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f17 = f14 * f13;
  f18 = f0 - f6;
  f19 = heapClassInst.heapFloat[r4 + numDefine3];
  heapClassInst.heapFloat[fp + numDefineNeg26] = f19;
  f20 = heapClassInst.heapFloat[r4 + numDefine7];
  heapClassInst.heapFloat[fp + numDefineNeg27] = f20;
  r1 = r1 >> numDefine2;
  f0 = f0 + f6;
  f6 = f1 - f3;
  f1 = f1 + f3;
  f3 = heapClassInst.heapFloat[r4 + numDefine11];
  heapClassInst.heapFloat[fp + numDefineNeg21] = f3;
  f7 = f8 + f7;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg17];
  f8 = f11 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg19];
  f21 = f2 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg18];
  f22 = f11 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f23 = f2 * f13;
  f4 = f4 + f5;
  f5 = f18 * f19;
  f16 = f16 + f17;
  f17 = f18 * f20;
  f10 = f10 * f12;
  f14 = f14 * f15;
  f7 = f9 - f7;
  f9 = heapClassInst.heapFloat[r1 + numDefine2];
  f24 = heapClassInst.heapFloat[r1 + numDefine6];
  f25 = heapClassInst.heapFloat[r1 + 1];
  f26 = heapClassInst.heapFloat[r1 + numDefine5];
  f4 = f4 + f5;
  f5 = f16 + f17;
  r2 = heapClassInst.heap32[r1 + numDefine48];
  f13 = heapClassInst.heapFloat[fp + numDefineNeg17];
  f16 = f0 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg19];
  f17 = f6 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg18];
  f27 = f0 * f13;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f28 = f6 * f13;
  f8 = f8 + f21;
  f21 = f1 * f19;
  f22 = f22 + f23;
  f23 = f1 * f20;
  f11 = f11 * f12;
  f2 = f2 * f15;
  f10 = f10 + f14;
  f14 = f18 * f3;
  f18 = heapClassInst.heapFloat[r1 + numDefine3];
  f29 = heapClassInst.heapFloat[r1 + numDefine7];
  f8 = f8 + f21;
  f21 = f22 + f23;
  f22 = heapClassInst.heapFloat[r1 + numDefine10];
  f23 = heapClassInst.heapFloat[r1 + numDefine9];
  r2 = r2 >> numDefine2;
  f10 = f10 + f14;
  r3 = heapClassInst.heap32[r4 + numDefine48];
  f14 = f16 + f17;
  f16 = f7 * f19;
  f17 = f27 + f28;
  f27 = f7 * f20;
  f0 = f0 * f12;
  f6 = f6 * f15;
  f2 = f11 + f2;
  f1 = f1 * f3;
  f11 = f25 * f4;
  f28 = f26 * f5;
  f30 = f9 * f4;
  f3 = f24 * f5;
  f12 = heapClassInst.heapFloat[r1 + numDefine11];
  f14 = f14 + f16;
  f16 = f17 + f27;
  f1 = f2 + f1;
  r5 = r3 >> numDefine2;
  f2 = heapClassInst.heapFloat[r2 + numDefine12];
  f0 = f0 + f6;
  f6 = heapClassInst.heapFloat[fp + numDefineNeg21];
  f7 = f7 * f6;
  f17 = f25 * f8;
  f27 = f26 * f21;
  f6 = f9 * f8;
  f13 = f24 * f21;
  f11 = f11 + f28;
  f28 = f23 * f10;
  f3 = f30 + f3;
  f30 = f22 * f10;
  f4 = f18 * f4;
  f5 = f29 * f5;
  f0 = f0 + f7;
  r5 = heapClassInst.heap32[r5];
  f7 = f25 * f14;
  f15 = f26 * f16;
  f19 = f9 * f14;
  f20 = f24 * f16;
  f17 = f17 + f27;
  f27 = f23 * f1;
  f6 = f6 + f13;
  f13 = f22 * f1;
  f8 = f18 * f8;
  f21 = f29 * f21;
  f11 = f11 + f28;
  f2 = -f2;
  f3 = f3 + f30;
  f28 = heapClassInst.heapFloat[r2 + numDefine13];
  f4 = f4 + f5;
  f5 = f12 * f10;
  r5 = r5 >> numDefine2;
  f10 = f17 + f27;
  f6 = f6 + f13;
  f7 = f7 + f15;
  f13 = f23 * f0;
  f15 = f19 + f20;
  f17 = f22 * f0;
  f14 = f18 * f14;
  f16 = f29 * f16;
  f8 = f8 + f21;
  f1 = f12 * f1;
  f11 = f11 * f2;
  f3 = f3 * f28;
  f4 = f4 + f5;
  f5 = heapClassInst.heapFloat[r2 + numDefine14];
  f19 = heapClassInst.heapFloat[r4 + numDefine13];
  heapClassInst.heapFloat[fp + numDefineNeg22] = f19;
  f19 = heapClassInst.heapFloat[r4 + numDefine14];
  heapClassInst.heapFloat[fp + numDefineNeg23] = f19;
  f20 = heapClassInst.heapFloat[r4 + numDefine15];
  heapClassInst.heapFloat[fp + numDefineNeg28] = f20;
  f21 = heapClassInst.heapFloat[r1 + numDefine14];
  f27 = heapClassInst.heapFloat[r1 + numDefine15];
  heapClassInst.heapFloat[fp + numDefineNeg29] = f27;
  f7 = f7 + f13;
  f13 = f15 + f17;
  f1 = f8 + f1;
  f8 = heapClassInst.heapFloat[r1 + numDefine13];
  r4 = heapClassInst.heap32[r5 + numDefine15];
  f14 = f14 + f16;
  f0 = f12 * f0;
  f10 = f10 * f2;
  f6 = f6 * f28;
  f3 = f11 - f3;
  f4 = f4 * f5;
  r5 = sp + numDefineNeg16;
  f0 = f14 + f0;
  f2 = f7 * f2;
  f7 = f13 * f28;
  f6 = f10 - f6;
  f1 = f1 * f5;
  f3 = f3 - f4;
  r6 = r5 >> numDefine2;
  f2 = f2 - f7;
  f0 = f0 * f5;
  f1 = f6 - f1;
  heapClassInst.heapFloat[fp + numDefineNeg4] = f3;
  f0 = f2 - f0;
  heapClassInst.heapFloat[r6 + 1] = f1;
  heapClassInst.heapFloat[r6 + numDefine2] = f0;
  heapClassInst.heap32[r6 + numDefine3] = 0;
  r6 = sp + numDefineNeg32;
  heapClassInst.heap32[g0] = r6;
  heapClassInst.heap32[g0 + 1] = r3;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg17];
  f0 = f13 * f9;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg18];
  f1 = f13 * f24;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg19];
  f2 = f13 * f9;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f3 = f13 * f24;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg17];
  f4 = f13 * f25;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg18];
  f5 = f13 * f26;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg19];
  f6 = f13 * f25;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f7 = f13 * f26;
  functionTable[r4 >> numDefine2](i7);
  f8 = -f8;
  r3 = r6 >> numDefine2;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg17];
  f10 = f13 * f18;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg18];
  f11 = f13 * f29;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg19];
  f13 = f13 * f18;
  f14 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f14 = f14 * f29;
  f0 = f0 + f1;
  f1 = heapClassInst.heapFloat[fp + numDefineNeg24];
  f15 = f1 * f22;
  f2 = f2 + f3;
  f3 = heapClassInst.heapFloat[fp + numDefineNeg25];
  f16 = f3 * f22;
  f19 = heapClassInst.heapFloat[fp + numDefineNeg26];
  f17 = f19 * f9;
  f20 = heapClassInst.heapFloat[fp + numDefineNeg27];
  f28 = f20 * f24;
  f4 = f4 + f5;
  f5 = f1 * f23;
  f6 = f6 + f7;
  f7 = f3 * f23;
  f30 = f19 * f25;
  f1 = f20 * f26;
  f10 = f10 + f11;
  f11 = heapClassInst.heapFloat[fp + numDefineNeg24];
  f11 = f11 * f12;
  f13 = f13 + f14;
  f3 = f3 * f12;
  f14 = f19 * f18;
  f19 = f20 * f29;
  f0 = f0 + f15;
  f15 = heapClassInst.heapFloat[fp + numDefineNeg8];
  f4 = f4 + f5;
  f2 = f2 + f16;
  f5 = heapClassInst.heapFloat[r3 + 1];
  f6 = f6 + f7;
  f7 = f17 + f28;
  f16 = heapClassInst.heapFloat[fp + numDefineNeg21];
  f17 = f16 * f22;
  f20 = heapClassInst.heapFloat[fp + numDefineNeg22];
  f28 = f9 * f20;
  f16 = heapClassInst.heapFloat[fp + numDefineNeg23];
  f16 = f24 * f16;
  f9 = f9 * f8;
  f24 = f24 * f21;
  f1 = f30 + f1;
  f30 = heapClassInst.heapFloat[fp + numDefineNeg21];
  f20 = f30 * f23;
  f27 = heapClassInst.heapFloat[fp + numDefineNeg22];
  f27 = f25 * f27;
  f30 = heapClassInst.heapFloat[fp + numDefineNeg23];
  f30 = f26 * f30;
  f25 = f25 * f8;
  f26 = f26 * f21;
  f10 = f10 + f11;
  f3 = f13 + f3;
  f11 = f14 + f19;
  f13 = heapClassInst.heapFloat[fp + numDefineNeg21];
  f13 = f13 * f12;
  f14 = heapClassInst.heapFloat[fp + numDefineNeg22];
  f14 = f18 * f14;
  f19 = heapClassInst.heapFloat[fp + numDefineNeg23];
  f19 = f29 * f19;
  f8 = f18 * f8;
  f18 = f29 * f21;
  f0 = f0 * f15;
  f2 = f2 * f5;
  f7 = f7 + f17;
  f17 = heapClassInst.heapFloat[r3 + numDefine2];
  f1 = f1 + f20;
  f16 = f28 + f16;
  f20 = heapClassInst.heapFloat[fp + numDefineNeg28];
  f21 = f22 * f20;
  f9 = f9 - f24;
  f24 = heapClassInst.heapFloat[fp + numDefineNeg29];
  f22 = f22 * f24;
  f4 = f4 * f15;
  f6 = f6 * f5;
  f27 = f27 + f30;
  f28 = f23 * f20;
  f25 = f25 - f26;
  f23 = f23 * f24;
  f11 = f11 + f13;
  f10 = f10 * f15;
  f3 = f3 * f5;
  f5 = f14 + f19;
  f13 = f12 * f20;
  f8 = f8 - f18;
  f12 = f12 * f24;
  f0 = f0 + f2;
  f2 = f7 * f17;
  f7 = f16 + f21;
  f9 = f9 - f22;
  f4 = f4 + f6;
  f1 = f1 * f17;
  f6 = f27 + f28;
  f14 = f25 - f23;
  f3 = f10 + f3;
  f10 = f11 * f17;
  f5 = f5 + f13;
  f8 = f8 - f12;
  f0 = f0 + f2;
  f2 = f7 + f9;
  f1 = f4 + f1;
  f4 = f6 + f14;
  f3 = f3 + f10;
  f5 = f5 + f8;
  f0 = f0 + f2;
  f2 = heapClassInst.heapFloat[r2 + numDefine13];
  f1 = f1 + f4;
  f4 = heapClassInst.heapFloat[r2 + numDefine12];
  f6 = f4 * f1;
  f7 = f2 * f0;
  f3 = f3 + f5;
  f5 = heapClassInst.heapFloat[r2 + numDefine14];
  r0 = r0 >> numDefine2;
  f6 = f6 + f7;
  f7 = f5 * f3;
  r0 = heapClassInst.heap32[r0 + numDefine3];
  f6 = f6 + f7;
  f7 = heapClassInst.heapFloat[r2 + numDefine16];
  f6 = f6 - f7;
  r3 = r0 >> numDefine2;
  r4 = heapClassInst.heap32[fp + numDefine4];
  f7 = heapClassInst.heapFloat[r1 + numDefine9];
  f8 = heapClassInst.heapFloat[r1 + numDefine10];
  f9 = heapClassInst.heapFloat[r1 + numDefine11];
  f10 = heapClassInst.heapFloat[r1 + numDefine15];
  f11 = heapClassInst.heapFloat[r1 + numDefine5];
  f12 = heapClassInst.heapFloat[r1 + numDefine6];
  f13 = heapClassInst.heapFloat[r1 + numDefine7];
  f14 = heapClassInst.heapFloat[r1 + numDefine14];
  f15 = heapClassInst.heapFloat[r1 + 1];
  f16 = heapClassInst.heapFloat[r1 + numDefine2];
  f17 = heapClassInst.heapFloat[r1 + numDefine3];
  f18 = heapClassInst.heapFloat[r1 + numDefine13];
  f19 = heapClassInst.heapFloat[r3 + numDefine280];
  r3 = r4 >> numDefine2;
  heapClassInst.heap32[r3 + 1] = r0;
  if (!(f19 <= f6)) {
    f5 = f5 * f6;
    f2 = f2 * f6;
    f4 = f4 * f6;
    f3 = f3 - f5;
    f0 = f0 - f2;
    f1 = f1 - f4;
    f2 = heapClassInst.heapFloat[r2 + numDefine12];
    f4 = heapClassInst.heapFloat[r1 + 1];
    f5 = heapClassInst.heapFloat[r2 + numDefine13];
    f19 = heapClassInst.heapFloat[r1 + numDefine2];
    f20 = heapClassInst.heapFloat[r1 + numDefine5];
    f21 = heapClassInst.heapFloat[r1 + numDefine6];
    f4 = f4 * f2;
    f19 = f19 * f5;
    f22 = heapClassInst.heapFloat[r2 + numDefine14];
    f23 = heapClassInst.heapFloat[r1 + numDefine3];
    f24 = heapClassInst.heapFloat[r1 + numDefine9];
    f25 = heapClassInst.heapFloat[r1 + numDefine10];
    f26 = heapClassInst.heapFloat[r1 + numDefine11];
    f27 = heapClassInst.heapFloat[r1 + numDefine7];
    f20 = f20 * f2;
    f21 = f21 * f5;
    f4 = f4 + f19;
    f19 = f23 * f22;
    r0 = sp + numDefineNeg48;
    f2 = f24 * f2;
    f5 = f25 * f5;
    f20 = f20 + f21;
    f21 = f27 * f22;
    f4 = f4 + f19;
    f15 = f15 * f1;
    f16 = f16 * f0;
    r1 = r0 >> numDefine2;
    f2 = f2 + f5;
    f5 = f26 * f22;
    f19 = f20 + f21;
    heapClassInst.heapFloat[fp + numDefineNeg12] = f4;
    f4 = f11 * f1;
    f11 = f12 * f0;
    f12 = f15 + f16;
    f15 = f17 * f3;
    f2 = f2 + f5;
    heapClassInst.heapFloat[r1 + 1] = f19;
    heapClassInst.heapFloat[r1 + numDefine2] = f2;
    f1 = f7 * f1;
    f0 = f8 * f0;
    f2 = f4 + f11;
    f4 = f13 * f3;
    f5 = f12 + f15;
    r2 = sp + numDefineNeg64;
    f0 = f1 + f0;
    f1 = f9 * f3;
    f2 = f2 + f4;
    f3 = f5 + f18;
    heapClassInst.heap32[r1 + numDefine3] = 0;
    r1 = r2 >> numDefine2;
    f0 = f0 + f1;
    f1 = f2 + f14;
    heapClassInst.heapFloat[fp + numDefineNeg16] = f3;
    f0 = f0 + f10;
    heapClassInst.heapFloat[r1 + 1] = f1;
    heapClassInst.heapFloat[r1 + numDefine2] = f0;
    heapClassInst.heap32[r1 + numDefine3] = 0;
    r1 = heapClassInst.heap32[r3];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine4];
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    heapClassInst.heapFloat[g0 + numDefine3] = f6;
    functionTable[r1 >> numDefine2](i7);
  }
  return;
}

function zn31btConvexPlaneCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg56;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine3];
  if (!(r2 === 0)) {
    r2 = heapClassInst.heap32[fp + 1];
    r3 = heapClassInst.heap32[fp + numDefine2];
    r4 = heapClassInst.heap32[fp + numDefine4];
    r5 = heapClassInst.heapU8[r0 + numDefine16];
    r6 = r5 === 0 ? r2 : r3;
    r5 = r5 === 0 ? r3 : r2;
    r6 = r6 >> numDefine2;
    r5 = r5 >> numDefine2;
    r6 = heapClassInst.heap32[r6 + numDefine48];
    r5 = heapClassInst.heap32[r5 + numDefine48];
    r7 = sp + numDefineNeg32;
    r8 = r7 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg8] = 0;
    heapClassInst.heap32[r8 + 1] = 0;
    heapClassInst.heap32[r8 + numDefine2] = 0;
    heapClassInst.heap32[r8 + numDefine3] = numDefine53216;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r7;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    heapClassInst.heap32[g0 + numDefine3] = r3;
    heapClassInst.heap32[g0 + numDefine4] = r4;
    r7 = r4 >> numDefine2;
    zn31btConvexPlaneCollisionAlgorithm20collideSingleContactERK12btQuaternionP17btCollisionObjectS4RK16btDispatcherInfoP16btManifoldResult(i7);
    r8 = heapClassInst.heap32[r7 + 1];
    r8 = r8 >> numDefine2;
    r8 = heapClassInst.heap32[r8 + numDefine279];
    r9 = heapClassInst.heap32[r1 + numDefine6];
    repeat3: do {
      if (!(r8 >= r9)) {
        r5 = r5 >> numDefine2;
        f0 = heapClassInst.heapFloat[r5 + numDefine14];
        f1 = 0;
        if (f0 < f1) {
          f2 = -f0;
        } else {
          f2 = f0;
        }
        f3 = numDefineFloat742;
        if (f2 <= f3) {
          f0 = heapClassInst.heapFloat[r5 + numDefine12];
          f2 = heapClassInst.heapFloat[r5 + numDefine13];
          f0 = f0 * f0;
          f2 = f2 * f2;
          f0 = f0 + f2;
          heapClassInst.heapFloat[g0] = f0;
          sqrtf(i7);
          f2 = heapClassInst.heapFloat[r5 + numDefine13];
          f3 = 1;
          f2 = -f2;
          f0 = f3 / commonVariable.fg0;
          f4 = heapClassInst.heapFloat[r5 + numDefine12];
          f3 = f0 * f2;
          f2 = f4 * f0;
          f0 = f1;
        } else {
          f2 = heapClassInst.heapFloat[r5 + numDefine13];
          f2 = f2 * f2;
          f0 = f0 * f0;
          f0 = f2 + f0;
          heapClassInst.heapFloat[g0] = f0;
          sqrtf(i7);
          f2 = heapClassInst.heapFloat[r5 + numDefine14];
          f3 = 1;
          f2 = -f2;
          f0 = f3 / commonVariable.fg0;
          f3 = heapClassInst.heapFloat[r5 + numDefine13];
          f2 = f0 * f2;
          f0 = f3 * f0;
          f3 = 0;
        }
        r8 = r6 >> numDefine2;
        r8 = heapClassInst.heap32[r8];
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine4];
        heapClassInst.heap32[g0] = r6;
        f4 = f3 * f3;
        f5 = f2 * f2;
        functionTable[r8 >> numDefine2](i7);
        f6 = commonVariable.fg0;
        f4 = f4 + f5;
        f5 = f0 * f0;
        f4 = f4 + f5;
        heapClassInst.heapFloat[g0] = f4;
        sqrtf(i7);
        f4 = commonVariable.fg0;
        if (f4 !== f1) {
          f1 = numDefineFloat064;
          f1 = f1 / f6;
          f5 = numDefineFloat05;
          f6 = numDefineFloat366;
          f7 = numDefineFloat183;
          f8 = f1 * f5;
          f1 = f1 > f6 ? f7 : f8;
          heapClassInst.heapFloat[g0] = f1;
          sinf(i7);
          heapClassInst.heapFloat[g0] = f1;
          f1 = commonVariable.fg0 / f4;
          f0 = f0 * f1;
          f2 = f2 * f1;
          f1 = f3 * f1;
          r6 = 0;
          cosf(i7);
          f3 = commonVariable.fg0;
          repeat15: while (true) {
            r8 = heapClassInst.heap32[r1 + numDefine5];
            if (r8 > r6) {
              f4 = heapClassInst.heapFloat[r5 + numDefine12];
              f6 = heapClassInst.heapFloat[r5 + numDefine13];
              f7 = heapClassInst.heapFloat[r5 + numDefine14];
              f4 = f4 * f4;
              f6 = f6 * f6;
              f4 = f4 + f6;
              f6 = f7 * f7;
              f4 = f4 + f6;
              heapClassInst.heapFloat[g0] = f4;
              sqrtf(i7);
              f4 = commonVariable.fg0;
              f6 = 0;
              if (f4 !== f6) {
                f6 = numDefineFloat265;
                f7 = r8;
                f8 = r6;
                f6 = f6 / f7;
                f6 = f8 * f6;
                f6 = f6 * f5;
                heapClassInst.heapFloat[g0] = f6;
                sinf(i7);
                f7 = commonVariable.fg0;
                heapClassInst.heapFloat[g0] = f6;
                cosf(i7);
                f4 = f7 / f4;
                f7 = heapClassInst.heapFloat[r5 + numDefine12];
                f7 = f7 * f4;
                f8 = heapClassInst.heapFloat[r5 + numDefine13];
                f8 = f8 * f4;
                f9 = heapClassInst.heapFloat[r5 + numDefine14];
                f10 = commonVariable.fg0 * f3;
                f11 = f1 * f7;
                f12 = commonVariable.fg0 * f1;
                f13 = f3 * f7;
                f4 = f9 * f4;
                f9 = f10 + f11;
                f10 = f2 * f8;
                f11 = f12 - f13;
                f12 = f0 * f8;
                f13 = commonVariable.fg0 * f2;
                f14 = f3 * f8;
                f9 = f9 + f10;
                f10 = f0 * f4;
                f11 = f11 - f12;
                f12 = f2 * f4;
                f13 = f13 - f14;
                f14 = f1 * f4;
                f15 = commonVariable.fg0 * f0;
                f16 = f3 * f4;
                f9 = f9 + f10;
                f10 = f11 + f12;
                f11 = f13 - f14;
                f12 = f0 * f7;
                f13 = f15 - f16;
                f14 = f2 * f7;
                f11 = f11 + f12;
                f12 = f9 * f7;
                f15 = f10 * commonVariable.fg0;
                f13 = f13 - f14;
                f14 = f1 * f8;
                f13 = f13 + f14;
                f14 = f9 * f8;
                f16 = f11 * commonVariable.fg0;
                f12 = f12 + f15;
                f15 = f11 * f4;
                f17 = f9 * f4;
                f18 = f13 * commonVariable.fg0;
                f14 = f14 + f16;
                f16 = f13 * f7;
                f12 = f12 + f15;
                f15 = f13 * f8;
                r8 = sp + numDefineNeg16;
                f6 = f9 * commonVariable.fg0;
                f9 = f10 * f7;
                f17 = f17 + f18;
                f18 = f10 * f8;
                f14 = f14 + f16;
                f10 = f10 * f4;
                f12 = f12 - f15;
                r9 = r8 >> numDefine2;
                f6 = f6 - f9;
                f8 = f11 * f8;
                f9 = f17 + f18;
                f7 = f11 * f7;
                f10 = f14 - f10;
                heapClassInst.heapFloat[fp + numDefineNeg4] = f12;
                f6 = f6 - f8;
                f4 = f13 * f4;
                f7 = f9 - f7;
                heapClassInst.heapFloat[r9 + 1] = f10;
                f4 = f6 - f4;
                heapClassInst.heapFloat[r9 + numDefine2] = f7;
                heapClassInst.heapFloat[r9 + numDefine3] = f4;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r8;
                heapClassInst.heap32[g0 + numDefine2] = r2;
                heapClassInst.heap32[g0 + numDefine3] = r3;
                heapClassInst.heap32[g0 + numDefine4] = r4;
                r6 = (r6 + 1) | 0;
                zn31btConvexPlaneCollisionAlgorithm20collideSingleContactERK12btQuaternionP17btCollisionObjectS4RK16btDispatcherInfoP16btManifoldResult(i7);
              } else {
                break repeat15;
              }
            } else {
              break repeat3;
            }
          }
        }
        r0 = twoEStr115;
        r1 = twoEStr685;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine61;
        assertNew(i7);
      }
    } while (false);
    r0 = heapClassInst.heapU8[r0 + numDefine8];
    if (!(r0 === 0)) {
      r0 = heapClassInst.heap32[r1 + numDefine3];
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0 + numDefine279];
      if (!(r0 === 0)) {
        r0 = heapClassInst.heap32[r7 + 1];
        if (r0 !== 0) {
          r1 = r0 >> numDefine2;
          r2 = heapClassInst.heap32[r1 + numDefine279];
          if (!(r2 === 0)) {
            r1 = heapClassInst.heap32[r1 + numDefine277];
            r2 = heapClassInst.heap32[r7 + numDefine34];
            if (r1 === r2) {
              r1 = (r4 + numDefine8) | 0;
              r2 = (r4 + numDefine72) | 0;
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r1;
              heapClassInst.heap32[g0 + numDefine2] = r2;
              zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
            } else {
              r1 = (r4 + numDefine72) | 0;
              r4 = (r4 + numDefine8) | 0;
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r1;
              heapClassInst.heap32[g0 + numDefine2] = r4;
              zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
              return;
            }
          }
        } else {
          r0 = twoEStr59;
          r4 = twoEStr160;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r4;
          heapClassInst.heap32[g0 + numDefine2] = numDefine101;
          assertNew(i7);
        }
      }
    }
  }
  return;
}

function zn31btConvexPlaneCollisionAlgorithmD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv31btConvexPlaneCollisionAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine8];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine3];
    if (!(r1 === 0)) {
      r2 = heapClassInst.heap32[r2 + 1];
      r3 = r2 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine4];
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = r1;
      functionTable[r3 >> numDefine2](i7);
    }
  }
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn31btConvexPlaneCollisionAlgorithmD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv31btConvexPlaneCollisionAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r0 = heapClassInst.heapU8[r0 + numDefine8];
  if (!(r0 === 0)) {
    r0 = heapClassInst.heap32[r2 + numDefine3];
    if (!(r0 === 0)) {
      r1 = heapClassInst.heap32[r2 + 1];
      r2 = r1 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2 + numDefine4];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      functionTable[r2 >> numDefine2](i7);
    }
  }
  return;
}

function zn31btDefaultCollisionConfiguration25getPersistentManifoldPoolEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine4];
  commonVariable.rg0 = r0;
  return;
}

function zn31btDefaultCollisionConfiguration25getCollisionAlgorithmPoolEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine6];
  commonVariable.rg0 = r0;
  return;
}

function zn31btDefaultCollisionConfiguration17getStackAllocatorEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine2];
  commonVariable.rg0 = r0;
  return;
}

function zn31btDefaultCollisionConfiguration16getSimplexSolverEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine8];
  commonVariable.rg0 = r0;
  return;
}

function zn31btConvexPlaneCollisionAlgorithm10CreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn31btConvexPlaneCollisionAlgorithm10CreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn31btConvexPlaneCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine28;
  r1 = heapClassInst.heap32[fp];
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r3 = r1 >> numDefine2;
  r4 = ztv20btCollisionAlgorithm;
  r5 = heapClassInst.heap32[r3 + numDefine3];
  r3 = heapClassInst.heap32[r3 + numDefine2];
  r1 = heapClassInst.heapU8[r1 + numDefine4];
  r6 = r2 >> numDefine2;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r6] = r4;
  r0 = heapClassInst.heap32[r0];
  r4 = ztv31btConvexPlaneCollisionAlgorithm;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r6 + 1] = r0;
  r7 = 0;
  heapClassInst.heap32[r6] = r4;
  r4 = heapClassInst.heap32[fp + numDefine2];
  r8 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap8[r2 + numDefine8] = r7;
  heapClassInst.heap32[r6 + numDefine3] = 0;
  if (r1 !== 0) {
    r1 = 1;
    r6 = r2 >> numDefine2;
    heapClassInst.heap8[r2 + numDefine16] = r1;
    heapClassInst.heap32[r6 + numDefine5] = r3;
    r3 = r0 >> numDefine2;
    heapClassInst.heap32[r6 + numDefine6] = r5;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine6];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r8;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    functionTable[r3 >> numDefine2](i7);
    r0 = commonVariable.rg0;
    if (!(r0 === 0)) {
      r0 = heapClassInst.heap32[r6 + 1];
      r3 = r0 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine3];
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r8;
      heapClassInst.heap32[g0 + numDefine2] = r4;
      functionTable[r3 >> numDefine2](i7);
      heapClassInst.heap32[r6 + numDefine3] = commonVariable.rg0;
      heapClassInst.heap8[r2 + numDefine8] = r1;
    }
  } else {
    r1 = r2 >> numDefine2;
    heapClassInst.heap8[r2 + numDefine16] = r7;
    heapClassInst.heap32[r1 + numDefine5] = r3;
    r3 = r0 >> numDefine2;
    heapClassInst.heap32[r1 + numDefine6] = r5;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine6];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r4;
    heapClassInst.heap32[g0 + numDefine2] = r8;
    functionTable[r3 >> numDefine2](i7);
    r0 = commonVariable.rg0;
    if (!(r0 === 0)) {
      r0 = heapClassInst.heap32[r1 + 1];
      r3 = r0 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine3];
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = r8;
      functionTable[r3 >> numDefine2](i7);
      r3 = 1;
      heapClassInst.heap32[r1 + numDefine3] = commonVariable.rg0;
      heapClassInst.heap8[r2 + numDefine8] = r3;
    }
  }
  commonVariable.rg0 = r2;
  return;
}

function zn33btConvexConcaveCollisionAlgorithm10CreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn33btConvexConcaveCollisionAlgorithm10CreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn33btConvexConcaveCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine80;
  r1 = ztv20btCollisionAlgorithm;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r1 = (r1 + numDefine8) | 0;
  r3 = r2 >> numDefine2;
  heapClassInst.heap32[r3] = r1;
  r1 = heapClassInst.heap32[r0];
  r4 = ztv33btConvexConcaveCollisionAlgorithm;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r3 + 1] = r1;
  r1 = 0;
  heapClassInst.heap32[r3] = r4;
  heapClassInst.heap8[r2 + numDefine8] = r1;
  r1 = ztv24btConvexTriangleCallback;
  r0 = heapClassInst.heap32[r0];
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r3 + numDefine3] = r1;
  heapClassInst.heap32[r3 + numDefine15] = r0;
  r1 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[r3 + numDefine16] = 0;
  r4 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[r3 + numDefine4] = r1;
  r5 = r0 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine5] = r4;
  r5 = heapClassInst.heap32[r5];
  r5 = r5 >> numDefine2;
  r5 = heapClassInst.heap32[r5 + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  functionTable[r5 >> numDefine2](i7);
  heapClassInst.heap32[r3 + numDefine19] = commonVariable.rg0;
  r1 = heapClassInst.heap32[r3 + numDefine15];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine5];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
  functionTable[r3 >> numDefine2](i7);
  commonVariable.rg0 = r2;
  return;
}

function zn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn33btConvexConcaveCollisionAlgorithm17SwappedCreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine80;
  r1 = ztv20btCollisionAlgorithm;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r1 = (r1 + numDefine8) | 0;
  r3 = r2 >> numDefine2;
  heapClassInst.heap32[r3] = r1;
  r1 = heapClassInst.heap32[r0];
  r4 = ztv33btConvexConcaveCollisionAlgorithm;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r3 + 1] = r1;
  r1 = 1;
  heapClassInst.heap32[r3] = r4;
  heapClassInst.heap8[r2 + numDefine8] = r1;
  r1 = ztv24btConvexTriangleCallback;
  r0 = heapClassInst.heap32[r0];
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r3 + numDefine3] = r1;
  heapClassInst.heap32[r3 + numDefine15] = r0;
  r1 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[r3 + numDefine16] = 0;
  r4 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[r3 + numDefine4] = r1;
  r5 = r0 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine5] = r4;
  r5 = heapClassInst.heap32[r5];
  r5 = r5 >> numDefine2;
  r5 = heapClassInst.heap32[r5 + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  functionTable[r5 >> numDefine2](i7);
  heapClassInst.heap32[r3 + numDefine19] = commonVariable.rg0;
  r1 = heapClassInst.heap32[r3 + numDefine15];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine5];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
  functionTable[r3 >> numDefine2](i7);
  commonVariable.rg0 = r2;
  return;
}

function zn28btCompoundCollisionAlgorithm10CreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn28btCompoundCollisionAlgorithm10CreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn28btCompoundCollisionAlgorithm10CreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn28btCompoundCollisionAlgorithm10CreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn28btCompoundCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine44;
  functionTable[r2 >> numDefine2](i7);
  r1 = commonVariable.rg0;
  r2 = ztv20btCollisionAlgorithm;
  r3 = r1 >> numDefine2;
  r2 = (r2 + numDefine8) | 0;
  heapClassInst.heap32[r3] = r2;
  r2 = heapClassInst.heap32[r0];
  r4 = ztv28btCompoundCollisionAlgorithm;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r3 + 1] = r2;
  r2 = 1;
  heapClassInst.heap32[r3] = r4;
  heapClassInst.heap8[r1 + numDefine24] = r2;
  heapClassInst.heap32[r3 + numDefine5] = 0;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  r2 = 0;
  heapClassInst.heap32[r3 + numDefine4] = 0;
  heapClassInst.heap8[r1 + numDefine28] = r2;
  r0 = heapClassInst.heap32[r0 + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[r3 + numDefine8] = r0;
  r0 = r4 >> numDefine2;
  heapClassInst.heap8[r1 + numDefine36] = r2;
  r0 = heapClassInst.heap32[r0 + numDefine48];
  r0 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r0 + 1];
  if (r2 === numDefine31) {
    r2 = heapClassInst.heap32[fp + numDefine3];
    r3 = r1 >> numDefine2;
    r0 = heapClassInst.heap32[r0 + numDefine17];
    heapClassInst.heap32[r3 + numDefine10] = r0;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r4;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    zn28btCompoundCollisionAlgorithm26preallocateChildAlgorithmsEP17btCollisionObjectS1(i7);
    commonVariable.rg0 = r1;
    return;
  } else {
    r0 = twoEStr99;
    r1 = twoEStr1100;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine32;
    assertNew(i7);
  }
}

function zn28btCompoundCollisionAlgorithm17SwappedCreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn28btCompoundCollisionAlgorithm17SwappedCreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn28btCompoundCollisionAlgorithm17SwappedCreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine44;
  functionTable[r2 >> numDefine2](i7);
  r1 = commonVariable.rg0;
  r2 = ztv20btCollisionAlgorithm;
  r3 = r1 >> numDefine2;
  r2 = (r2 + numDefine8) | 0;
  heapClassInst.heap32[r3] = r2;
  r2 = heapClassInst.heap32[r0];
  r4 = ztv28btCompoundCollisionAlgorithm;
  r4 = (r4 + numDefine8) | 0;
  heapClassInst.heap32[r3 + 1] = r2;
  r2 = 1;
  heapClassInst.heap32[r3] = r4;
  heapClassInst.heap8[r1 + numDefine24] = r2;
  heapClassInst.heap32[r3 + numDefine5] = 0;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  heapClassInst.heap32[r3 + numDefine4] = 0;
  heapClassInst.heap8[r1 + numDefine28] = r2;
  r0 = heapClassInst.heap32[r0 + 1];
  r2 = heapClassInst.heap32[fp + numDefine3];
  r4 = 0;
  heapClassInst.heap32[r3 + numDefine8] = r0;
  r0 = r2 >> numDefine2;
  heapClassInst.heap8[r1 + numDefine36] = r4;
  r0 = heapClassInst.heap32[r0 + numDefine48];
  r0 = r0 >> numDefine2;
  r3 = heapClassInst.heap32[r0 + 1];
  if (r3 === numDefine31) {
    r3 = heapClassInst.heap32[fp + numDefine2];
    r4 = r1 >> numDefine2;
    r0 = heapClassInst.heap32[r0 + numDefine17];
    heapClassInst.heap32[r4 + numDefine10] = r0;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    zn28btCompoundCollisionAlgorithm26preallocateChildAlgorithmsEP17btCollisionObjectS1(i7);
    commonVariable.rg0 = r1;
    return;
  } else {
    r0 = twoEStr99;
    r1 = twoEStr1100;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine32;
    assertNew(i7);
  }
}

function zn16btEmptyAlgorithm10CreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn16btEmptyAlgorithm10CreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn16btEmptyAlgorithm10CreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn16btEmptyAlgorithm10CreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn16btEmptyAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine8;
  r1 = ztv20btCollisionAlgorithm;
  functionTable[r2 >> numDefine2](i7);
  r3 = commonVariable.rg0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r3] = r1;
  r0 = heapClassInst.heap32[r0];
  r1 = ztv16btEmptyAlgorithm;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r3 + 1] = r0;
  heapClassInst.heap32[r3] = r1;
  return;
}

function zn32btSphereSphereCollisionAlgorithm10CreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn32btSphereSphereCollisionAlgorithm10CreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn32btSphereSphereCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine16;
  r1 = ztv20btCollisionAlgorithm;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r3 = r2 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r3] = r1;
  r0 = heapClassInst.heap32[r0];
  r1 = ztv32btSphereSphereCollisionAlgorithm;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r3 + 1] = r0;
  r4 = 0;
  heapClassInst.heap32[r3] = r1;
  heapClassInst.heap8[r2 + numDefine8] = r4;
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine3];
  r4 = heapClassInst.heap32[fp + numDefine2];
  r5 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  functionTable[r1 >> numDefine2](i7);
  r1 = 1;
  heapClassInst.heap32[r3 + numDefine3] = commonVariable.rg0;
  heapClassInst.heap8[r2 + numDefine8] = r1;
  commonVariable.rg0 = r2;
  return;
}

function zn34btSphereTriangleCollisionAlgorithm10CreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn34btSphereTriangleCollisionAlgorithm10CreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn34btSphereTriangleCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine20;
  functionTable[r2 >> numDefine2](i7);
  r1 = commonVariable.rg0;
  r2 = heapClassInst.heap32[fp];
  r3 = ztv20btCollisionAlgorithm;
  r4 = heapClassInst.heap32[r0 + 1];
  r2 = heapClassInst.heapU8[r2 + numDefine4];
  r5 = r1 >> numDefine2;
  r3 = (r3 + numDefine8) | 0;
  heapClassInst.heap32[r5] = r3;
  r0 = heapClassInst.heap32[r0];
  r3 = ztv34btSphereTriangleCollisionAlgorithm;
  r3 = (r3 + numDefine8) | 0;
  heapClassInst.heap32[r5 + 1] = r0;
  r6 = 0;
  heapClassInst.heap32[r5] = r3;
  heapClassInst.heap8[r1 + numDefine8] = r6;
  heapClassInst.heap32[r5 + numDefine3] = r4;
  heapClassInst.heap8[r1 + numDefine16] = r2;
  if (!(r4 !== 0)) {
    r2 = heapClassInst.heap32[fp + numDefine2];
    r3 = heapClassInst.heap32[fp + numDefine3];
    r4 = r0 >> numDefine2;
    r4 = heapClassInst.heap32[r4];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine3];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = r3;
    r0 = r1 >> numDefine2;
    functionTable[r4 >> numDefine2](i7);
    r3 = 1;
    heapClassInst.heap32[r0 + numDefine3] = commonVariable.rg0;
    heapClassInst.heap8[r1 + numDefine8] = r3;
  }
  commonVariable.rg0 = r1;
  return;
}

function zn26btBoxBoxCollisionAlgorithm10CreateFuncD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn26btBoxBoxCollisionAlgorithm10CreateFuncD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn26btBoxBoxCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = numDefine16;
  functionTable[r2 >> numDefine2](i7);
  r1 = commonVariable.rg0;
  r2 = ztv20btCollisionAlgorithm;
  r3 = r1 >> numDefine2;
  r2 = (r2 + numDefine8) | 0;
  heapClassInst.heap32[r3] = r2;
  r0 = heapClassInst.heap32[r0];
  r2 = ztv26btBoxBoxCollisionAlgorithm;
  r2 = (r2 + numDefine8) | 0;
  heapClassInst.heap32[r3 + 1] = r0;
  r4 = 0;
  heapClassInst.heap32[r3] = r2;
  heapClassInst.heap8[r1 + numDefine8] = r4;
  r2 = r0 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine6];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  functionTable[r2 >> numDefine2](i7);
  r0 = commonVariable.rg0;
  if (!(r0 === 0)) {
    r0 = r1 >> numDefine2;
    r2 = heapClassInst.heap32[r0 + 1];
    r5 = r2 >> numDefine2;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine3];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r3;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    functionTable[r5 >> numDefine2](i7);
    r3 = 1;
    heapClassInst.heap32[r0 + numDefine3] = commonVariable.rg0;
    heapClassInst.heap8[r1 + numDefine8] = r3;
  }
  commonVariable.rg0 = r1;
  return;
}

function zn31btDefaultCollisionConfiguration31getCollisionAlgorithmCreateFuncEii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + numDefine2];
  if (r0 !== numDefine8) {
    label = numDefine3;
  } else {
    if (r2 !== numDefine8) {
      label = numDefine3;
    } else {
      r0 = (r1 + numDefine64) | 0;
      label = numDefine30;
    }
  }
  repeat4: do {
    if (label === numDefine3) {
      if (!(r0 !== numDefine8)) {
        if (!(r2 !== 1)) {
          r0 = (r1 + numDefine72) | 0;
          break repeat4;
        }
      }
      if (!(r0 !== 1)) {
        if (!(r2 !== numDefine8)) {
          r0 = (r1 + numDefine76) | 0;
          break repeat4;
        }
      }
      r3 = r2 | r0;
      if (r3 !== 0) {
        if (!(r0 > numDefine19)) {
          if (!(r2 !== numDefine28)) {
            r0 = (r1 + numDefine84) | 0;
            break repeat4;
          }
        }
        if (!(r2 > numDefine19)) {
          if (!(r0 !== numDefine28)) {
            r0 = (r1 + numDefine80) | 0;
            break repeat4;
          }
        }
        repeat24: do {
          if (r0 > numDefine19) {
            if (r2 < numDefine20) {
              r3 = (r0 + numDefineNeg21) | 0;
              if (uint(r3) < uint(numDefine9)) {
                r0 = (r1 + numDefine48) | 0;
                break repeat4;
              }
            }
            if (r0 === numDefine31) {
              r0 = (r1 + numDefine52) | 0;
              break repeat4;
            } else {
              break repeat24;
            }
          } else {
            if (r2 > numDefine19) {
              r0 = (r2 + numDefineNeg21) | 0;
              if (uint(r0) < uint(numDefine9)) {
                r0 = (r1 + numDefine44) | 0;
                break repeat4;
              }
            } else {
              r0 = (r1 + numDefine40) | 0;
              break repeat4;
            }
          }
        } while (false);
        if (r2 !== numDefine31) {
          r0 = (r1 + numDefine60) | 0;
        } else {
          r0 = (r1 + numDefine56) | 0;
        }
      } else {
        r0 = (r1 + numDefine68) | 0;
      }
    }
  } while (false);
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0];
  commonVariable.rg0 = r0;
  return;
}

function zn31btDefaultCollisionConfigurationD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv31btDefaultCollisionConfiguration;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine12];
  repeat1: do {
    if (!(r1 === 0)) {
      r1 = heapClassInst.heap32[r2 + numDefine2];
      r3 = r1 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine2];
      if (r4 === 0) {
        r1 = heapClassInst.heapU8[r1 + numDefine16];
        if (!(r1 !== 0)) {
          r1 = heapClassInst.heap32[r3];
          if (!(r1 === 0)) {
            r4 = gNumAlignedFree;
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r4];
            r5 = (r5 + 1) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r4] = r5;
            r1 = heapClassInst.heap32[r1 + -1];
            heapClassInst.heap32[g0] = r1;
            free(i7);
          }
        }
        heapClassInst.heap32[r3] = 0;
        heapClassInst.heap32[r3 + numDefine2] = 0;
        r1 = heapClassInst.heap32[r2 + numDefine2];
        r3 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[r3 + numDefine2];
        if (r4 === 0) {
          r1 = heapClassInst.heapU8[r1 + numDefine16];
          if (!(r1 !== 0)) {
            r1 = heapClassInst.heap32[r3];
            if (!(r1 === 0)) {
              r4 = gNumAlignedFree;
              r4 = r4 >> numDefine2;
              r5 = heapClassInst.heap32[r4];
              r5 = (r5 + 1) | 0;
              r1 = r1 >> numDefine2;
              heapClassInst.heap32[r4] = r5;
              r1 = heapClassInst.heap32[r1 + -1];
              heapClassInst.heap32[g0] = r1;
              free(i7);
            }
          }
          heapClassInst.heap32[r3] = 0;
          heapClassInst.heap32[r3 + numDefine2] = 0;
          r1 = heapClassInst.heap32[r2 + numDefine2];
          if (r1 === 0) {
            break repeat1;
          } else {
            r3 = gNumAlignedFree;
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r3];
            r4 = (r4 + 1) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r3] = r4;
            r1 = heapClassInst.heap32[r1 + -1];
            heapClassInst.heap32[g0] = r1;
            free(i7);
            break repeat1;
          }
        }
      }
      r0 = twoEStr128;
      r1 = twoEStr1129;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine49;
      assertNew(i7);
    }
  } while (false);
  r1 = heapClassInst.heapU8[r0 + numDefine28];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine6];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine4];
    if (r3 !== 0) {
      r1 = gNumAlignedFree;
      r1 = r1 >> numDefine2;
      r4 = heapClassInst.heap32[r1];
      r4 = (r4 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r1] = r4;
      r1 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
      r1 = heapClassInst.heap32[r2 + numDefine6];
    }
    if (!(r1 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r1 = heapClassInst.heapU8[r0 + numDefine20];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine4];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine4];
    if (r3 !== 0) {
      r1 = gNumAlignedFree;
      r1 = r1 >> numDefine2;
      r4 = heapClassInst.heap32[r1];
      r4 = (r4 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r1] = r4;
      r1 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
      r1 = heapClassInst.heap32[r2 + numDefine4];
    }
    if (!(r1 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r1 = heapClassInst.heap32[r2 + numDefine10];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine10];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine11];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine11];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine12];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine12];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine13];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine13];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine14];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine14];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine15];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine15];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine16];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine16];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine18];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine18];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine19];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine19];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine17];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine17];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine21];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine21];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine20];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine20];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine8];
  if (!(r1 === 0)) {
    r3 = gNumAlignedFree;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  r1 = heapClassInst.heap32[r2 + numDefine9];
  r3 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r2 + numDefine9];
  if (!(r1 === 0)) {
    r2 = gNumAlignedFree;
    r2 = r2 >> numDefine2;
    r3 = heapClassInst.heap32[r2];
    r3 = (r3 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r2] = r3;
    r1 = heapClassInst.heap32[r1 + -1];
    heapClassInst.heap32[g0] = r1;
    free(i7);
  }
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn31btDefaultCollisionConfigurationD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  zn31btDefaultCollisionConfigurationD2Ev(i7);
  return;
}

function zn31btDefaultCollisionConfigurationD2Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv31btDefaultCollisionConfiguration;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine12];
  repeat1: do {
    if (!(r1 === 0)) {
      r1 = heapClassInst.heap32[r2 + numDefine2];
      r3 = r1 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine2];
      if (r4 === 0) {
        r1 = heapClassInst.heapU8[r1 + numDefine16];
        if (!(r1 !== 0)) {
          r1 = heapClassInst.heap32[r3];
          if (!(r1 === 0)) {
            r4 = gNumAlignedFree;
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r4];
            r5 = (r5 + 1) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r4] = r5;
            r1 = heapClassInst.heap32[r1 + -1];
            heapClassInst.heap32[g0] = r1;
            free(i7);
          }
        }
        heapClassInst.heap32[r3] = 0;
        heapClassInst.heap32[r3 + numDefine2] = 0;
        r1 = heapClassInst.heap32[r2 + numDefine2];
        r3 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[r3 + numDefine2];
        if (r4 === 0) {
          r1 = heapClassInst.heapU8[r1 + numDefine16];
          if (!(r1 !== 0)) {
            r1 = heapClassInst.heap32[r3];
            if (!(r1 === 0)) {
              r4 = gNumAlignedFree;
              r4 = r4 >> numDefine2;
              r5 = heapClassInst.heap32[r4];
              r5 = (r5 + 1) | 0;
              r1 = r1 >> numDefine2;
              heapClassInst.heap32[r4] = r5;
              r1 = heapClassInst.heap32[r1 + -1];
              heapClassInst.heap32[g0] = r1;
              free(i7);
            }
          }
          heapClassInst.heap32[r3] = 0;
          heapClassInst.heap32[r3 + numDefine2] = 0;
          r1 = heapClassInst.heap32[r2 + numDefine2];
          if (r1 === 0) {
            break repeat1;
          } else {
            r3 = gNumAlignedFree;
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r3];
            r4 = (r4 + 1) | 0;
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r3] = r4;
            r1 = heapClassInst.heap32[r1 + -1];
            heapClassInst.heap32[g0] = r1;
            free(i7);
            break repeat1;
          }
        }
      }
      r0 = twoEStr128;
      r1 = twoEStr1129;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine49;
      assertNew(i7);
    }
  } while (false);
  r1 = heapClassInst.heapU8[r0 + numDefine28];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine6];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine4];
    if (r3 !== 0) {
      r1 = gNumAlignedFree;
      r1 = r1 >> numDefine2;
      r4 = heapClassInst.heap32[r1];
      r4 = (r4 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r1] = r4;
      r1 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
      r1 = heapClassInst.heap32[r2 + numDefine6];
    }
    if (!(r1 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r0 = heapClassInst.heapU8[r0 + numDefine20];
  if (!(r0 === 0)) {
    r0 = heapClassInst.heap32[r2 + numDefine4];
    r1 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine4];
    if (r1 !== 0) {
      r0 = gNumAlignedFree;
      r0 = r0 >> numDefine2;
      r3 = heapClassInst.heap32[r0];
      r3 = (r3 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r0] = r3;
      r0 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r0;
      free(i7);
      r0 = heapClassInst.heap32[r2 + numDefine4];
    }
    if (!(r0 === 0)) {
      r1 = gNumAlignedFree;
      r1 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r1];
      r3 = (r3 + 1) | 0;
      r0 = r0 >> numDefine2;
      heapClassInst.heap32[r1] = r3;
      r0 = heapClassInst.heap32[r0 + -1];
      heapClassInst.heap32[g0] = r0;
      free(i7);
    }
  }
  r0 = heapClassInst.heap32[r2 + numDefine10];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine10];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine11];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine11];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine12];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine12];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine13];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine13];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine14];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine14];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine15];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine15];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine16];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine16];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine18];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine18];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine19];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine19];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine17];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine17];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine21];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine21];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine20];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine20];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine8];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r1];
    r3 = (r3 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r3;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  r0 = heapClassInst.heap32[r2 + numDefine9];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = heapClassInst.heap32[r2 + numDefine9];
  if (!(r0 === 0)) {
    r1 = gNumAlignedFree;
    r1 = r1 >> numDefine2;
    r2 = heapClassInst.heap32[r1];
    r2 = (r2 + 1) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r1] = r2;
    r0 = heapClassInst.heap32[r0 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}

function zn16btEmptyAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn16btEmptyAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn16btEmptyAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  f0 = 1;
  commonVariable.fg0 = f0;
  return;
}

function zn16btEmptyAlgorithmD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv16btEmptyAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn16btEmptyAlgorithmD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv16btEmptyAlgorithm;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn16btManifoldResultD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv16btManifoldResult;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn16btManifoldResultD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv16btManifoldResult;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn16btManifoldResult15addContactPointERK9btVector3S2F(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let f29: number = 0.0;
  let f30: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg304;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + 1];
  if (r1 !== 0) {
    f0 = heapClassInst.heapFloat[fp + numDefine3];
    r2 = r1 >> numDefine2;
    f1 = heapClassInst.heapFloat[r2 + numDefine280];
    if (!(f1 < f0)) {
      r3 = heapClassInst.heap32[fp + 1];
      r4 = heapClassInst.heap32[fp + numDefine2];
      r3 = r3 >> numDefine2;
      r4 = r4 >> numDefine2;
      f1 = heapClassInst.heapFloat[r3 + numDefine2];
      heapClassInst.heapFloat[fp + numDefineNeg71] = f1;
      f2 = heapClassInst.heapFloat[r3 + 1];
      f3 = heapClassInst.heapFloat[r3];
      f4 = heapClassInst.heapFloat[r4 + numDefine2];
      f1 = f1 * f0;
      f5 = heapClassInst.heapFloat[r4 + 1];
      f6 = f2 * f0;
      f7 = heapClassInst.heapFloat[r4];
      f8 = f3 * f0;
      r5 = heapClassInst.heap32[r2 + numDefine277];
      r6 = heapClassInst.heap32[r0 + numDefine34];
      f1 = f4 + f1;
      f6 = f5 + f6;
      f8 = f7 + f8;
      if (r5 === r6) {
        f9 = heapClassInst.heapFloat[r0 + numDefine14];
        f10 = heapClassInst.heapFloat[r0 + numDefine15];
        f11 = heapClassInst.heapFloat[r0 + numDefine30];
        f13 = heapClassInst.heapFloat[r0 + numDefine31];
        f14 = heapClassInst.heapFloat[r0 + numDefine4];
        f9 = f8 - f9;
        f15 = heapClassInst.heapFloat[r0 + numDefine3];
        f12 = heapClassInst.heapFloat[r0 + numDefine2];
        f16 = heapClassInst.heapFloat[r0 + numDefine8];
        f10 = f6 - f10;
        f17 = heapClassInst.heapFloat[r0 + numDefine7];
        f18 = heapClassInst.heapFloat[r0 + numDefine6];
        f19 = heapClassInst.heapFloat[r0 + numDefine16];
        f20 = heapClassInst.heapFloat[r0 + numDefine20];
        f11 = f7 - f11;
        f21 = heapClassInst.heapFloat[r0 + numDefine19];
        f22 = heapClassInst.heapFloat[r0 + numDefine18];
        f23 = heapClassInst.heapFloat[r0 + numDefine24];
        f13 = f5 - f13;
        f24 = heapClassInst.heapFloat[r0 + numDefine23];
        f25 = heapClassInst.heapFloat[r0 + numDefine22];
        f26 = heapClassInst.heapFloat[r0 + numDefine32];
        f14 = f14 * f9;
        f16 = f16 * f10;
        f27 = heapClassInst.heapFloat[r0 + numDefine12];
        f19 = f1 - f19;
        f28 = heapClassInst.heapFloat[r0 + numDefine11];
        f29 = heapClassInst.heapFloat[r0 + numDefine10];
        f15 = f15 * f9;
        f17 = f17 * f10;
        f9 = f12 * f9;
        f10 = f18 * f10;
        f12 = f20 * f11;
        f18 = f23 * f13;
        f20 = heapClassInst.heapFloat[r0 + numDefine28];
        f23 = f4 - f26;
        f26 = heapClassInst.heapFloat[r0 + numDefine27];
        f30 = heapClassInst.heapFloat[r0 + numDefine26];
        f21 = f21 * f11;
        f24 = f24 * f13;
        f11 = f22 * f11;
        f13 = f25 * f13;
        f14 = f14 + f16;
        f16 = f27 * f19;
        f15 = f15 + f17;
        f17 = f28 * f19;
        f9 = f9 + f10;
        f10 = f29 * f19;
        f12 = f12 + f18;
        f18 = f20 * f23;
        f19 = f21 + f24;
        f20 = f26 * f23;
        f11 = f11 + f13;
        f21 = f30 * f23;
        f13 = f14 + f16;
        f14 = f15 + f17;
        f9 = f9 + f10;
        f10 = f12 + f18;
        f15 = f19 + f20;
        f11 = f11 + f21;
      } else {
        f9 = heapClassInst.heapFloat[r0 + numDefine30];
        f10 = heapClassInst.heapFloat[r0 + numDefine31];
        f11 = heapClassInst.heapFloat[r0 + numDefine14];
        f12 = heapClassInst.heapFloat[r0 + numDefine15];
        f13 = heapClassInst.heapFloat[r0 + numDefine20];
        f9 = f8 - f9;
        f14 = heapClassInst.heapFloat[r0 + numDefine19];
        f15 = heapClassInst.heapFloat[r0 + numDefine18];
        f16 = heapClassInst.heapFloat[r0 + numDefine24];
        f10 = f6 - f10;
        f17 = heapClassInst.heapFloat[r0 + numDefine23];
        f18 = heapClassInst.heapFloat[r0 + numDefine22];
        f19 = heapClassInst.heapFloat[r0 + numDefine32];
        f20 = heapClassInst.heapFloat[r0 + numDefine4];
        f11 = f7 - f11;
        f21 = heapClassInst.heapFloat[r0 + numDefine3];
        f22 = heapClassInst.heapFloat[r0 + numDefine2];
        f23 = heapClassInst.heapFloat[r0 + numDefine8];
        f12 = f5 - f12;
        f24 = heapClassInst.heapFloat[r0 + numDefine7];
        f25 = heapClassInst.heapFloat[r0 + numDefine6];
        f26 = heapClassInst.heapFloat[r0 + numDefine16];
        f13 = f13 * f9;
        f16 = f16 * f10;
        f27 = heapClassInst.heapFloat[r0 + numDefine28];
        f19 = f1 - f19;
        f28 = heapClassInst.heapFloat[r0 + numDefine27];
        f29 = heapClassInst.heapFloat[r0 + numDefine26];
        f14 = f14 * f9;
        f17 = f17 * f10;
        f9 = f15 * f9;
        f10 = f18 * f10;
        f15 = f20 * f11;
        f18 = f23 * f12;
        f20 = heapClassInst.heapFloat[r0 + numDefine12];
        f23 = f4 - f26;
        f26 = heapClassInst.heapFloat[r0 + numDefine11];
        f30 = heapClassInst.heapFloat[r0 + numDefine10];
        f21 = f21 * f11;
        f24 = f24 * f12;
        f11 = f22 * f11;
        f12 = f25 * f12;
        f13 = f13 + f16;
        f16 = f27 * f19;
        f14 = f14 + f17;
        f17 = f28 * f19;
        f9 = f9 + f10;
        f10 = f29 * f19;
        f15 = f15 + f18;
        f18 = f20 * f23;
        f19 = f21 + f24;
        f20 = f26 * f23;
        f11 = f11 + f12;
        f12 = f30 * f23;
        f13 = f13 + f16;
        f14 = f14 + f17;
        f9 = f9 + f10;
        f10 = f15 + f18;
        f15 = f19 + f20;
        f11 = f11 + f12;
      }
      r7 = sp + numDefineNeg280;
      r8 = r7 >> numDefine2;
      heapClassInst.heapFloat[fp + numDefineNeg70] = f9;
      heapClassInst.heapFloat[r8 + 1] = f14;
      heapClassInst.heapFloat[r8 + numDefine2] = f13;
      heapClassInst.heap32[r8 + numDefine3] = 0;
      heapClassInst.heapFloat[r8 + numDefine4] = f11;
      heapClassInst.heapFloat[r8 + numDefine5] = f15;
      heapClassInst.heapFloat[r8 + numDefine6] = f10;
      heapClassInst.heap32[r8 + numDefine7] = 0;
      heapClassInst.heapFloat[r8 + numDefine16] = f3;
      heapClassInst.heapFloat[r8 + numDefine17] = f2;
      f2 = heapClassInst.heapFloat[fp + numDefineNeg71];
      heapClassInst.heapFloat[r8 + numDefine18] = f2;
      heapClassInst.heap32[r8 + numDefine19] = heapClassInst.heap32[r3 + numDefine3];
      heapClassInst.heapFloat[r8 + numDefine20] = f0;
      heapClassInst.heap32[r8 + numDefine21] = 0;
      heapClassInst.heap32[r8 + numDefine22] = 0;
      heapClassInst.heap32[r8 + numDefine27] = 0;
      r3 = 0;
      heapClassInst.heap32[r8 + numDefine28] = 0;
      heapClassInst.heap8[sp + numDefineNeg164] = r3;
      heapClassInst.heap32[r8 + numDefine30] = 0;
      heapClassInst.heap32[r8 + numDefine31] = 0;
      heapClassInst.heap32[r8 + numDefine32] = 0;
      heapClassInst.heap32[r8 + numDefine33] = 0;
      heapClassInst.heap32[r8 + numDefine34] = 0;
      heapClassInst.heap32[r8 + numDefine35] = 0;
      heapClassInst.heap32[r8 + numDefine36] = 0;
      heapClassInst.heap32[r8 + numDefine52] = 0;
      heapClassInst.heap32[r8 + numDefine60] = 0;
      heapClassInst.heap32[r8 + numDefine68] = 0;
      heapClassInst.heapFloat[r8 + numDefine12] = f8;
      heapClassInst.heapFloat[r8 + numDefine13] = f6;
      heapClassInst.heapFloat[r8 + numDefine14] = f1;
      heapClassInst.heap32[r8 + numDefine15] = 0;
      heapClassInst.heapFloat[r8 + numDefine8] = f7;
      heapClassInst.heapFloat[r8 + numDefine9] = f5;
      heapClassInst.heapFloat[r8 + numDefine10] = f4;
      heapClassInst.heap32[r8 + numDefine11] = heapClassInst.heap32[r4 + numDefine3];
      r4 = heapClassInst.heap32[r2 + numDefine279];
      repeat9: do {
        if (r4 > 0) {
          f1 = heapClassInst.heapFloat[r2 + numDefine280];
          f1 = f1 * f1;
          r10 = 0;
          r9 = -1;
          while (true) {
            r11 = (r10 * numDefine69) | 0;
            r11 = r11 << numDefine2;
            r11 = (r1 + r11) | 0;
            r11 = r11 >> numDefine2;
            f2 = heapClassInst.heapFloat[r11 + 1];
            f3 = heapClassInst.heapFloat[r11 + numDefine2];
            f2 = f2 - f9;
            f3 = f3 - f14;
            f4 = heapClassInst.heapFloat[r11 + numDefine3];
            f4 = f4 - f13;
            f2 = f2 * f2;
            f3 = f3 * f3;
            f2 = f2 + f3;
            f3 = f4 * f4;
            f2 = f2 + f3;
            r11 = (r10 + 1) | 0;
            r9 = f2 < f1 ? r10 : r9;
            f1 = f2 < f1 ? f2 : f1;
            r10 = r11;
            if (!(r4 !== r11)) {
              break repeat9;
            }
          }
        } else {
          r9 = -1;
        }
      } while (false);
      r4 = heapClassInst.heap32[r0 + numDefine35];
      r4 = r4 >> numDefine2;
      r10 = r6 >> numDefine2;
      f1 = heapClassInst.heapFloat[r10 + numDefine56];
      f2 = heapClassInst.heapFloat[r4 + numDefine56];
      f1 = f1 * f2;
      f2 = numDefineNeg10;
      f1 = f1 < f2 ? f2 : f1;
      f2 = numDefine10;
      f1 = f1 > f2 ? f2 : f1;
      heapClassInst.heapFloat[r8 + numDefine21] = f1;
      f1 = heapClassInst.heapFloat[r10 + numDefine57];
      f2 = heapClassInst.heapFloat[r4 + numDefine57];
      f1 = f1 * f2;
      heapClassInst.heapFloat[r8 + numDefine22] = f1;
      if (r5 === r6) {
        r4 = heapClassInst.heap32[r0 + numDefine36];
        heapClassInst.heap32[r8 + numDefine23] = r4;
        r4 = heapClassInst.heap32[r0 + numDefine37];
        heapClassInst.heap32[r8 + numDefine24] = r4;
        r4 = heapClassInst.heap32[r0 + numDefine38];
        heapClassInst.heap32[r8 + numDefine25] = r4;
        r0 = heapClassInst.heap32[r0 + numDefine39];
        heapClassInst.heap32[r8 + numDefine26] = r0;
      } else {
        r4 = heapClassInst.heap32[r0 + numDefine37];
        heapClassInst.heap32[r8 + numDefine23] = r4;
        r4 = heapClassInst.heap32[r0 + numDefine36];
        heapClassInst.heap32[r8 + numDefine24] = r4;
        r4 = heapClassInst.heap32[r0 + numDefine39];
        heapClassInst.heap32[r8 + numDefine25] = r4;
        r0 = heapClassInst.heap32[r0 + numDefine38];
        heapClassInst.heap32[r8 + numDefine26] = r0;
      }
      f1 = heapClassInst.heapFloat[r2 + numDefine280];
      if (r9 < 0) {
        if (f1 >= f0) {
          r0 = heapClassInst.heap32[r2 + numDefine279];
          if (r0 !== numDefine4) {
            r4 = (r0 + 1) | 0;
            heapClassInst.heap32[r2 + numDefine279] = r4;
          } else {
            f1 = heapClassInst.heapFloat[r2 + numDefine21];
            r0 = -1;
            f2 = heapClassInst.heapFloat[r2 + numDefine90];
            f3 = f1 < f0 ? f1 : f0;
            r4 = 1;
            f4 = heapClassInst.heapFloat[r2 + numDefine159];
            f5 = f2 < f3 ? f2 : f3;
            r5 = numDefine2;
            f6 = heapClassInst.heapFloat[r2 + numDefine228];
            f7 = f4 < f5 ? f4 : f5;
            if (f6 >= f7) {
              r6 = f1 >= f0 ? r0 : r3;
              r6 = f2 < f3 ? r4 : r6;
              r6 = f4 < f5 ? r5 : r6;
              if (r6 === 0) {
                f0 = heapClassInst.heapFloat[r2 + numDefine210];
                f1 = heapClassInst.heapFloat[r2 + numDefine141];
                f2 = heapClassInst.heapFloat[r2 + numDefine209];
                f3 = heapClassInst.heapFloat[r2 + numDefine140];
                f4 = heapClassInst.heapFloat[r2 + numDefine208];
                f5 = heapClassInst.heapFloat[r2 + numDefine139];
                f6 = heapClassInst.heapFloat[r2 + numDefine72];
                f7 = heapClassInst.heapFloat[r2 + numDefine71];
                f8 = heapClassInst.heapFloat[r2 + numDefine70];
                f10 = 0;
                r6 = r3;
                label = numDefine28;
              } else {
                label = numDefine26;
              }
            } else {
              r6 = numDefine3;
              label = numDefine26;
            }
            if (label === numDefine26) {
              f6 = heapClassInst.heapFloat[r2 + numDefine72];
              f0 = heapClassInst.heapFloat[r2 + numDefine210];
              f1 = heapClassInst.heapFloat[r2 + numDefine141];
              f8 = heapClassInst.heapFloat[r2 + numDefine70];
              f2 = heapClassInst.heapFloat[r2 + numDefine209];
              f3 = heapClassInst.heapFloat[r2 + numDefine140];
              f7 = heapClassInst.heapFloat[r2 + numDefine71];
              f4 = heapClassInst.heapFloat[r2 + numDefine208];
              f5 = heapClassInst.heapFloat[r2 + numDefine139];
              f10 = f13 - f6;
              f11 = f2 - f3;
              f12 = f9 - f8;
              f15 = f0 - f1;
              f16 = f14 - f7;
              f17 = f4 - f5;
              f18 = f16 * f15;
              f19 = f10 * f11;
              f10 = f10 * f17;
              f15 = f12 * f15;
              f18 = f18 - f19;
              f10 = f10 - f15;
              f11 = f12 * f11;
              f12 = f16 * f17;
              f11 = f11 - f12;
              f12 = f18 * f18;
              f10 = f10 * f10;
              f10 = f12 + f10;
              f11 = f11 * f11;
              f10 = f10 + f11;
              if (r6 === 1) {
                f11 = heapClassInst.heapFloat[r2 + numDefine3];
                f12 = heapClassInst.heapFloat[r2 + numDefine2];
                f15 = heapClassInst.heapFloat[r2 + 1];
                f16 = 0;
                r6 = r4;
                label = numDefine30;
              } else {
                label = numDefine28;
              }
            }
            if (label === numDefine28) {
              f11 = heapClassInst.heapFloat[r2 + numDefine3];
              f15 = heapClassInst.heapFloat[r2 + 1];
              f12 = heapClassInst.heapFloat[r2 + numDefine2];
              f16 = f13 - f11;
              f17 = f2 - f3;
              f18 = f9 - f15;
              f19 = f0 - f1;
              f20 = f14 - f12;
              f21 = f4 - f5;
              f22 = f20 * f19;
              f23 = f16 * f17;
              f16 = f16 * f21;
              f19 = f18 * f19;
              f22 = f22 - f23;
              f16 = f16 - f19;
              f17 = f18 * f17;
              f18 = f20 * f21;
              f17 = f17 - f18;
              f18 = f22 * f22;
              f16 = f16 * f16;
              f16 = f18 + f16;
              f17 = f17 * f17;
              f16 = f16 + f17;
              if (r6 === numDefine2) {
                f0 = 0;
                label = numDefine32;
              } else {
                label = numDefine30;
              }
            }
            if (label === numDefine30) {
              f17 = f13 - f11;
              f2 = f2 - f7;
              f18 = f9 - f15;
              f0 = f0 - f6;
              f19 = f14 - f12;
              f4 = f4 - f8;
              f20 = f19 * f0;
              f21 = f17 * f2;
              f17 = f17 * f4;
              f0 = f18 * f0;
              f20 = f20 - f21;
              f0 = f17 - f0;
              f2 = f18 * f2;
              f4 = f19 * f4;
              f2 = f2 - f4;
              f4 = f20 * f20;
              f0 = f0 * f0;
              f0 = f4 + f0;
              f2 = f2 * f2;
              f0 = f0 + f2;
              if (r6 === numDefine3) {
                f1 = 0;
                label = numDefine34;
              } else {
                label = numDefine32;
              }
            }
            if (label === numDefine32) {
              f2 = f13 - f11;
              f3 = f3 - f7;
              f4 = f9 - f15;
              f1 = f1 - f6;
              f6 = f14 - f12;
              f5 = f5 - f8;
              f7 = f6 * f1;
              f8 = f2 * f3;
              f2 = f2 * f5;
              f1 = f4 * f1;
              f7 = f7 - f8;
              f1 = f2 - f1;
              f2 = f4 * f3;
              f3 = f6 * f5;
              f2 = f2 - f3;
              f3 = f7 * f7;
              f1 = f1 * f1;
              f1 = f3 + f1;
              f2 = f2 * f2;
              f1 = f1 + f2;
              f2 = 0;
              if (f1 < f2) {
                f1 = -f1;
              }
            }
            f2 = 0;
            if (f0 < f2) {
              f0 = -f0;
            }
            if (f16 < f2) {
              f16 = -f16;
            }
            if (f10 < f2) {
              f10 = -f10;
            }
            f2 = numDefineNeg49440;
            r2 = 0;
            f3 = f10 > f2 ? f10 : f2;
            r0 = f10 <= f2 ? r0 : r2;
            f2 = f16 > f3 ? f16 : f3;
            r0 = f16 > f3 ? r4 : r0;
            f3 = f0 > f2 ? f0 : f2;
            r2 = numDefine3;
            r0 = f0 > f2 ? r5 : r0;
            r0 = f1 > f3 ? r2 : r0;
          }
          r0 = r0 < 0 ? r3 : r0;
          r0 = (r0 * numDefine276) | 0;
          r0 = (r1 + r0) | 0;
          r1 = r0 >> numDefine2;
          r1 = heapClassInst.heap32[r1 + numDefine28];
          if (r1 === 0) {
            r0 = (r0 + numDefine4) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r7;
            heapClassInst.heap32[g0 + numDefine2] = numDefine276;
            memcpy(i7);
          } else {
            r0 = twoEStr4438;
            r7 = twoEStr3437;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r7;
            heapClassInst.heap32[g0 + numDefine2] = numDefine190;
            assertNew(i7);
          }
        } else {
          r1 = twoEStr2149;
          r2 = twoEStr3437;
          heapClassInst.heap32[g0] = r1;
          heapClassInst.heap32[g0 + 1] = r2;
          heapClassInst.heap32[g0 + numDefine2] = numDefine168;
          assertNew(i7);
        }
      } else {
        if (f1 >= f0) {
          r2 = (r9 * numDefine276) | 0;
          r1 = (r1 + r2) | 0;
          r2 = r1 >> numDefine2;
          r3 = heapClassInst.heap32[r2 + numDefine37];
          if (r3 > -1) {
            f0 = heapClassInst.heapFloat[r2 + numDefine53];
            f1 = heapClassInst.heapFloat[r2 + numDefine61];
            f9 = heapClassInst.heapFloat[r2 + numDefine69];
            r0 = heapClassInst.heap32[r2 + numDefine28];
            r1 = (r1 + numDefine4) | 0;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r7;
            heapClassInst.heap32[g0 + numDefine2] = numDefine276;
            memcpy(i7);
            heapClassInst.heap32[r2 + numDefine28] = r0;
            heapClassInst.heapFloat[r2 + numDefine29] = f0;
            heapClassInst.heapFloat[r2 + numDefine31] = f1;
            heapClassInst.heapFloat[r2 + numDefine32] = f9;
            heapClassInst.heapFloat[r2 + numDefine53] = f0;
            heapClassInst.heapFloat[r2 + numDefine61] = f1;
            heapClassInst.heapFloat[r2 + numDefine69] = f9;
            heapClassInst.heap32[r2 + numDefine37] = r3;
            return;
          } else {
            r1 = twoEStr3150;
            r2 = twoEStr483;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = numDefine177;
            assertNew(i7);
          }
        } else {
          r1 = twoEStr2149;
          r2 = twoEStr483;
          heapClassInst.heap32[g0] = r1;
          heapClassInst.heap32[g0 + 1] = r2;
          heapClassInst.heap32[g0 + numDefine2] = numDefine165;
          assertNew(i7);
        }
      }
    }
    return;
  } else {
    r0 = twoEStr59;
    r1 = twoEStr5152;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine64;
    assertNew(i7);
  }
}

function zn25btSimulationIslandManager26storeIslandActivationStateEP16btCollisionWorld(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine2];
  if (!(r1 < 1)) {
    r1 = heapClassInst.heap32[fp];
    r2 = 0;
    r3 = r2;
    repeat3: while (true) {
      r4 = heapClassInst.heap32[r0 + numDefine4];
      r5 = r2 << numDefine2;
      r4 = (r4 + r5) | 0;
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      r5 = (r2 + 1) | 0;
      r6 = heapClassInst.heapU8[r4 + numDefine204];
      r6 = r6 & numDefine3;
      if (r6 !== 0) {
        r2 = r4 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine52] = -1;
        heapClassInst.heap32[r2 + numDefine53] = numDefineNeg2;
      } else {
        r6 = r1 >> numDefine2;
        r7 = heapClassInst.heap32[r6 + numDefine4];
        r8 = r3 << numDefine3;
        r9 = (r7 + r8) | 0;
        r9 = r9 >> numDefine2;
        r9 = heapClassInst.heap32[r9];
        if (r9 === r3) {
          r10 = r3;
        } else {
          r10 = r3;
          repeat11: while (true) {
            r9 = r9 << numDefine3;
            r10 = r10 << numDefine3;
            r9 = (r7 + r9) | 0;
            r7 = (r7 + r10) | 0;
            r9 = r9 >> numDefine2;
            r7 = r7 >> numDefine2;
            r10 = heapClassInst.heap32[r9];
            heapClassInst.heap32[r7] = r10;
            r10 = heapClassInst.heap32[r9];
            r7 = heapClassInst.heap32[r6 + numDefine4];
            r9 = r10 << numDefine3;
            r9 = (r7 + r9) | 0;
            r9 = r9 >> numDefine2;
            r9 = heapClassInst.heap32[r9];
            if (!(r9 !== r10)) {
              break repeat11;
            }
          }
        }
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r4 + numDefine52] = r10;
        r6 = heapClassInst.heap32[r6 + numDefine4];
        r6 = (r6 + r8) | 0;
        r6 = r6 >> numDefine2;
        r3 = (r3 + 1) | 0;
        heapClassInst.heap32[r6 + 1] = r2;
        heapClassInst.heap32[r4 + numDefine53] = -1;
      }
      r4 = heapClassInst.heap32[r0 + numDefine2];
      r2 = r5;
      if (r4 > r5) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function zn20btAlignedObjectArrayIP20btPersistentManifoldE17quickSortInternalI33btPersistentManifoldSortPredicateEEvTIi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = (r0 + r1) | 0;
  r3 = r2 >>> numDefine31;
  r4 = heapClassInst.heap32[fp];
  r2 = (r2 + r3) | 0;
  r3 = r4 >> numDefine2;
  r2 = r2 & numDefine83646;
  r5 = heapClassInst.heap32[r3 + numDefine3];
  r2 = r2 << 1;
  r2 = (r5 + r2) | 0;
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r5 = r1;
  r6 = r0;
  repeat1: while (true) {
    r7 = r2 >> numDefine2;
    r8 = heapClassInst.heap32[r7 + numDefine277];
    r8 = r8 >> numDefine2;
    r9 = heapClassInst.heap32[r3 + numDefine3];
    r8 = heapClassInst.heap32[r8 + numDefine52];
    repeat3: while (true) {
      r10 = r5 << numDefine2;
      r10 = (r9 + r10) | 0;
      r10 = r10 >> numDefine2;
      r11 = heapClassInst.heap32[r10];
      r12 = r11 >> numDefine2;
      r13 = heapClassInst.heap32[r12 + numDefine277];
      r13 = r13 >> numDefine2;
      r13 = heapClassInst.heap32[r13 + numDefine52];
      if (r13 < 0) {
        r13 = heapClassInst.heap32[r12 + numDefine278];
        r13 = r13 >> numDefine2;
        r13 = heapClassInst.heap32[r13 + numDefine52];
      }
      if (r8 < 0) {
        r12 = heapClassInst.heap32[r7 + numDefine278];
        r12 = r12 >> numDefine2;
        r12 = heapClassInst.heap32[r12 + numDefine52];
      } else {
        r12 = r8;
      }
      if (r13 < r12) {
        r5 = (r5 + 1) | 0;
        continue repeat3;
      } else {
        break repeat3;
      }
    }
    repeat13: while (true) {
      r12 = r6 << numDefine2;
      r13 = (r9 + r12) | 0;
      r13 = r13 >> numDefine2;
      r13 = heapClassInst.heap32[r13];
      if (r8 < 0) {
        r14 = heapClassInst.heap32[r7 + numDefine278];
        r14 = r14 >> numDefine2;
        r14 = heapClassInst.heap32[r14 + numDefine52];
      } else {
        r14 = r8;
      }
      r15 = r13 >> numDefine2;
      r16 = heapClassInst.heap32[r15 + numDefine277];
      r16 = r16 >> numDefine2;
      r16 = heapClassInst.heap32[r16 + numDefine52];
      if (r16 < 0) {
        r16 = heapClassInst.heap32[r15 + numDefine278];
        r16 = r16 >> numDefine2;
        r16 = heapClassInst.heap32[r16 + numDefine52];
      }
      if (r14 < r16) {
        r6 = (r6 + -1) | 0;
        continue repeat13;
      } else {
        break repeat13;
      }
    }
    if (r5 <= r6) {
      heapClassInst.heap32[r10] = r13;
      r7 = heapClassInst.heap32[r3 + numDefine3];
      r7 = (r7 + r12) | 0;
      r5 = (r5 + 1) | 0;
      r6 = (r6 + -1) | 0;
      r7 = r7 >> numDefine2;
      heapClassInst.heap32[r7] = r11;
    }
    if (r5 <= r6) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  if (!(r6 <= r1)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = r6;
    zn20btAlignedObjectArrayIP20btPersistentManifoldE17quickSortInternalI33btPersistentManifoldSortPredicateEEvTIi(i7);
  }
  if (!(r5 >= r0)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r5;
    heapClassInst.heap32[g0 + numDefine2] = r0;
    zn20btAlignedObjectArrayIP20btPersistentManifoldE17quickSortInternalI33btPersistentManifoldSortPredicateEEvTIi(i7);
  }
  return;
}

function zn25btSimulationIslandManager21updateActivationStateEP16btCollisionWorldP12btDispatcher(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r0 + numDefine2];
  repeat1: do {
    if (r2 > 0) {
      r3 = 0;
      r2 = r3;
      repeat3: while (true) {
        r4 = heapClassInst.heap32[r0 + numDefine4];
        r5 = r3 << numDefine2;
        r4 = (r4 + r5) | 0;
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r3 = (r3 + 1) | 0;
        r5 = heapClassInst.heapU8[r4 + numDefine204];
        r5 = r5 & numDefine3;
        if (r5 === 0) {
          r5 = (r2 + 1) | 0;
          r6 = r4 >> numDefine2;
          heapClassInst.heap32[r6 + numDefine52] = r2;
          r2 = r5;
        }
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r4 + numDefine53] = -1;
        heapClassInst.heap32[r4 + numDefine60] = numDefine53216;
        r4 = heapClassInst.heap32[r0 + numDefine2];
        if (r4 > r3) {
          continue repeat3;
        } else {
          break repeat1;
        }
      }
    } else {
      r2 = 0;
    }
  } while (false);
  r3 = r1 >> numDefine2;
  r4 = heapClassInst.heap32[r3 + numDefine2];
  repeat10: do {
    if (!(r4 > r2)) {
      if (!(r4 >= r2)) {
        r5 = heapClassInst.heap32[r3 + numDefine3];
        if (!(r5 >= r2)) {
          if (r2 !== 0) {
            r5 = gNumAlignedAllocs;
            r5 = r5 >> numDefine2;
            r6 = heapClassInst.heap32[r5];
            r7 = r2 << numDefine3;
            r6 = (r6 + 1) | 0;
            r7 = r7 | numDefine3;
            heapClassInst.heap32[r5] = r6;
            r5 = (r7 + numDefine16) | 0;
            heapClassInst.heap32[g0] = r5;
            mallocNew(i7);
            r5 = commonVariable.rg0;
            if (r5 !== 0) {
              r6 = 0;
              r7 = (r5 + numDefine4) | 0;
              r6 = (r6 - r7) | 0;
              r6 = r6 & numDefine15;
              r6 = (r5 + r6) | 0;
              r7 = (r6 + numDefine4) | 0;
              r6 = r6 >> numDefine2;
              heapClassInst.heap32[r6] = r5;
              r5 = r7;
            }
          } else {
            r5 = 0;
          }
          r6 = (r1 + numDefine16) | 0;
          if (r4 < 1) {
            r7 = r6 >> numDefine2;
            r8 = heapClassInst.heap32[r7];
          } else {
            r7 = 0;
            repeat23: while (true) {
              r8 = r6 >> numDefine2;
              r8 = heapClassInst.heap32[r8];
              r9 = r7 << numDefine3;
              r10 = (r8 + r9) | 0;
              r10 = r10 >> numDefine2;
              r9 = (r5 + r9) | 0;
              r11 = heapClassInst.heap32[r10 + 1];
              r10 = heapClassInst.heap32[r10];
              r9 = r9 >> numDefine2;
              r7 = (r7 + 1) | 0;
              heapClassInst.heap32[r9] = r10;
              heapClassInst.heap32[r9 + 1] = r11;
              if (!(r4 !== r7)) {
                break repeat23;
              }
            }
            r6 = (r1 + numDefine16) | 0;
          }
          if (!(r8 === 0)) {
            r7 = heapClassInst.heapU8[r1 + numDefine20];
            if (!(r7 === 0)) {
              r7 = gNumAlignedFree;
              r7 = r7 >> numDefine2;
              r9 = heapClassInst.heap32[r7];
              r9 = (r9 + 1) | 0;
              r8 = r8 >> numDefine2;
              heapClassInst.heap32[r7] = r9;
              r7 = heapClassInst.heap32[r8 + -1];
              heapClassInst.heap32[g0] = r7;
              free(i7);
            }
            r7 = r6 >> numDefine2;
            heapClassInst.heap32[r7] = 0;
          }
          r7 = 1;
          r6 = r6 >> numDefine2;
          heapClassInst.heap8[r1 + numDefine20] = r7;
          heapClassInst.heap32[r6] = r5;
          heapClassInst.heap32[r3 + numDefine3] = r2;
          if (r4 >= r2) {
            break repeat10;
          }
        }
        repeat33: while (true) {
          r1 = r4 << numDefine3;
          r5 = heapClassInst.heap32[r3 + numDefine4];
          r1 = (r5 + r1) | 0;
          r1 = r1 >> numDefine2;
          r4 = (r4 + 1) | 0;
          heapClassInst.heap32[r1] = 0;
          heapClassInst.heap32[r1 + 1] = 0;
          if (r2 !== r4) {
            continue repeat33;
          } else {
            break repeat10;
          }
        }
      }
    }
  } while (false);
  heapClassInst.heap32[r3 + numDefine2] = r2;
  repeat36: do {
    if (!(r2 < 1)) {
      r1 = 0;
      repeat38: while (true) {
        r4 = r1 << numDefine3;
        r5 = heapClassInst.heap32[r3 + numDefine4];
        r5 = (r5 + r4) | 0;
        r5 = r5 >> numDefine2;
        heapClassInst.heap32[r5] = r1;
        r5 = heapClassInst.heap32[r3 + numDefine4];
        r4 = (r5 + r4) | 0;
        r1 = (r1 + 1) | 0;
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r4 + 1] = 1;
        if (r2 !== r1) {
          continue repeat38;
        } else {
          break repeat36;
        }
      }
    }
  } while (false);
  r0 = heapClassInst.heap32[r0 + numDefine20];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine9];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = commonVariable.rg0;
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine9];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine5];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  r0 = commonVariable.rg0;
  repeat41: do {
    if (!(r2 < 1)) {
      r0 = (r0 + numDefine4) | 0;
      repeat43: while (true) {
        r1 = r0 >> numDefine2;
        r4 = heapClassInst.heap32[r1 + -1];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        if (!(r4 === 0)) {
          r1 = heapClassInst.heap32[r1];
          r1 = r1 >> numDefine2;
          r1 = heapClassInst.heap32[r1];
          if (!(r1 === 0)) {
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r4 + numDefine51];
            r5 = r5 & numDefine7;
            if (!(r5 !== 0)) {
              r5 = heapClassInst.heapU8[r1 + numDefine204];
              r5 = r5 & numDefine7;
              if (!(r5 !== 0)) {
                r4 = heapClassInst.heap32[r4 + numDefine52];
                r5 = heapClassInst.heap32[r3 + numDefine4];
                r6 = r4 << numDefine3;
                r6 = (r5 + r6) | 0;
                r6 = r6 >> numDefine2;
                r1 = r1 >> numDefine2;
                r6 = heapClassInst.heap32[r6];
                r1 = heapClassInst.heap32[r1 + numDefine52];
                if (!(r6 === r4)) {
                  repeat51: while (true) {
                    r6 = r6 << numDefine3;
                    r4 = r4 << numDefine3;
                    r6 = (r5 + r6) | 0;
                    r4 = (r5 + r4) | 0;
                    r5 = r6 >> numDefine2;
                    r4 = r4 >> numDefine2;
                    r6 = heapClassInst.heap32[r5];
                    heapClassInst.heap32[r4] = r6;
                    r4 = heapClassInst.heap32[r5];
                    r5 = heapClassInst.heap32[r3 + numDefine4];
                    r6 = r4 << numDefine3;
                    r6 = (r5 + r6) | 0;
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6];
                    if (!(r6 !== r4)) {
                      break repeat51;
                    }
                  }
                }
                r6 = r1 << numDefine3;
                r6 = (r5 + r6) | 0;
                r6 = r6 >> numDefine2;
                r6 = heapClassInst.heap32[r6];
                repeat54: do {
                  if (!(r6 === r1)) {
                    while (true) {
                      r6 = r6 << numDefine3;
                      r1 = r1 << numDefine3;
                      r6 = (r5 + r6) | 0;
                      r1 = (r5 + r1) | 0;
                      r5 = r6 >> numDefine2;
                      r1 = r1 >> numDefine2;
                      r6 = heapClassInst.heap32[r5];
                      heapClassInst.heap32[r1] = r6;
                      r1 = heapClassInst.heap32[r5];
                      r5 = heapClassInst.heap32[r3 + numDefine4];
                      r6 = r1 << numDefine3;
                      r6 = (r5 + r6) | 0;
                      r6 = r6 >> numDefine2;
                      r6 = heapClassInst.heap32[r6];
                      if (!(r6 !== r1)) {
                        break repeat54;
                      }
                    }
                  }
                } while (false);
                if (!(r4 === r1)) {
                  r4 = r4 << numDefine3;
                  r5 = (r5 + r4) | 0;
                  r5 = r5 >> numDefine2;
                  heapClassInst.heap32[r5] = r1;
                  r5 = heapClassInst.heap32[r3 + numDefine4];
                  r1 = r1 << numDefine3;
                  r1 = (r5 + r1) | 0;
                  r4 = (r5 + r4) | 0;
                  r1 = r1 >> numDefine2;
                  r4 = r4 >> numDefine2;
                  r5 = heapClassInst.heap32[r1 + 1];
                  r4 = heapClassInst.heap32[r4 + 1];
                  r4 = (r4 + r5) | 0;
                  heapClassInst.heap32[r1 + 1] = r4;
                }
              }
            }
          }
        }
        r2 = (r2 + -1) | 0;
        r0 = (r0 + numDefine16) | 0;
        if (r2 !== 0) {
          continue repeat43;
        } else {
          break repeat41;
        }
      }
    }
  } while (false);
  return;
}

function zn25btSimulationIslandManagerD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv25btSimulationIslandManager;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine14];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine60];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine14] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine60] = r1;
  heapClassInst.heap32[r2 + numDefine14] = 0;
  heapClassInst.heap32[r2 + numDefine12] = 0;
  heapClassInst.heap32[r2 + numDefine13] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine9];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine40];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine9] = 0;
  }
  heapClassInst.heap8[r0 + numDefine40] = r1;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine7] = 0;
  heapClassInst.heap32[r2 + numDefine8] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine20];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine4] = 0;
  }
  heapClassInst.heap8[r0 + numDefine20] = r1;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn25btSimulationIslandManagerD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv25btSimulationIslandManager;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine14];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine60];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine14] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine60] = r1;
  heapClassInst.heap32[r2 + numDefine14] = 0;
  heapClassInst.heap32[r2 + numDefine12] = 0;
  heapClassInst.heap32[r2 + numDefine13] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine9];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine40];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine9] = 0;
  }
  heapClassInst.heap8[r0 + numDefine40] = r1;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine7] = 0;
  heapClassInst.heap32[r2 + numDefine8] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine20];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine4] = 0;
  }
  heapClassInst.heap8[r0 + numDefine20] = r1;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  return;
}

function zn32btSphereSphereCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  f0 = 1;
  commonVariable.fg0 = f0;
  return;
}

function zn32btSphereSphereCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine3];
  if (!(r2 === 0)) {
    r0 = heapClassInst.heapU8[r0 + numDefine8];
    if (!(r0 === 0)) {
      r0 = heapClassInst.heap32[fp + 1];
      r3 = r0 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine2];
      r5 = heapClassInst.heap32[r3 + 1];
      if (r4 === r5) {
        r6 = 1;
        r7 = r5 << 1;
        r7 = r5 === 0 ? r6 : r7;
        if (!(r4 >= r7)) {
          if (r7 !== 0) {
            r2 = gNumAlignedAllocs;
            r2 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r2];
            r8 = r7 << numDefine2;
            r4 = (r4 + 1) | 0;
            r8 = r8 | numDefine3;
            heapClassInst.heap32[r2] = r4;
            r2 = (r8 + numDefine16) | 0;
            heapClassInst.heap32[g0] = r2;
            mallocNew(i7);
            r2 = commonVariable.rg0;
            if (r2 !== 0) {
              r4 = 0;
              r8 = (r2 + numDefine4) | 0;
              r4 = (r4 - r8) | 0;
              r4 = r4 & numDefine15;
              r4 = (r2 + r4) | 0;
              r8 = (r4 + numDefine4) | 0;
              r4 = r4 >> numDefine2;
              heapClassInst.heap32[r4] = r2;
              r2 = r8;
            }
          } else {
            r2 = 0;
          }
          r4 = (r0 + numDefine12) | 0;
          if (r5 < 1) {
            r8 = r4 >> numDefine2;
            r9 = heapClassInst.heap32[r8];
          } else {
            r8 = 0;
            repeat15: while (true) {
              r9 = r4 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r10 = r8 << numDefine2;
              r11 = (r9 + r10) | 0;
              r11 = r11 >> numDefine2;
              r10 = (r2 + r10) | 0;
              r11 = heapClassInst.heap32[r11];
              r8 = (r8 + 1) | 0;
              r10 = r10 >> numDefine2;
              heapClassInst.heap32[r10] = r11;
              if (!(r5 !== r8)) {
                break repeat15;
              }
            }
            r4 = (r0 + numDefine12) | 0;
          }
          if (r9 !== 0) {
            r8 = heapClassInst.heapU8[r0 + numDefine16];
            if (r8 !== 0) {
              r5 = gNumAlignedFree;
              r5 = r5 >> numDefine2;
              r8 = heapClassInst.heap32[r5];
              r8 = (r8 + 1) | 0;
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r5] = r8;
              r5 = heapClassInst.heap32[r9 + -1];
              heapClassInst.heap32[g0] = r5;
              free(i7);
              r5 = heapClassInst.heap32[r3 + 1];
            }
            r8 = r4 >> numDefine2;
            heapClassInst.heap32[r8] = 0;
          }
          r4 = r4 >> numDefine2;
          heapClassInst.heap8[r0 + numDefine16] = r6;
          heapClassInst.heap32[r4] = r2;
          heapClassInst.heap32[r3 + numDefine2] = r7;
          r2 = heapClassInst.heap32[r1 + numDefine3];
        }
      }
      r0 = r5 << numDefine2;
      r1 = heapClassInst.heap32[r3 + numDefine3];
      r0 = (r1 + r0) | 0;
      r0 = r0 >> numDefine2;
      heapClassInst.heap32[r0] = r2;
      r0 = heapClassInst.heap32[r3 + 1];
      r0 = (r0 + 1) | 0;
      heapClassInst.heap32[r3 + 1] = r0;
    }
  }
  return;
}

function zn32btSphereSphereCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine3];
  repeat1: do {
    if (!(r0 === 0)) {
      r1 = heapClassInst.heap32[fp + 1];
      r2 = heapClassInst.heap32[fp + numDefine2];
      r3 = heapClassInst.heap32[fp + numDefine4];
      r4 = r3 >> numDefine2;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r4 + 1] = r0;
      r0 = r2 >> numDefine2;
      f0 = heapClassInst.heapFloat[r1 + numDefine14];
      f1 = heapClassInst.heapFloat[r0 + numDefine14];
      f2 = heapClassInst.heapFloat[r1 + numDefine13];
      f3 = heapClassInst.heapFloat[r0 + numDefine13];
      f0 = f0 - f1;
      f1 = f2 - f3;
      f2 = heapClassInst.heapFloat[r1 + numDefine15];
      f3 = heapClassInst.heapFloat[r0 + numDefine15];
      f2 = f2 - f3;
      r1 = heapClassInst.heap32[r1 + numDefine48];
      r2 = heapClassInst.heap32[r0 + numDefine48];
      f3 = f1 * f1;
      f4 = f0 * f0;
      f3 = f3 + f4;
      f4 = f2 * f2;
      f3 = f3 + f4;
      heapClassInst.heapFloat[g0] = f3;
      sqrtf(i7);
      f3 = commonVariable.fg0;
      r1 = r1 >> numDefine2;
      r2 = r2 >> numDefine2;
      f4 = heapClassInst.heapFloat[r1 + numDefine7];
      f5 = heapClassInst.heapFloat[r1 + numDefine3];
      f6 = heapClassInst.heapFloat[r2 + numDefine7];
      f7 = heapClassInst.heapFloat[r2 + numDefine3];
      f6 = f6 * f7;
      f4 = f4 * f5;
      f4 = f4 + f6;
      repeat3: do {
        if (f4 >= f3) {
          r1 = sp + numDefineNeg16;
          r2 = r1 >> numDefine2;
          heapClassInst.heap32[fp + numDefineNeg4] = numDefine53216;
          heapClassInst.heap32[r2 + 1] = 0;
          f4 = f3 - f4;
          heapClassInst.heap32[r2 + numDefine2] = 0;
          heapClassInst.heap32[r2 + numDefine3] = 0;
          f5 = numDefineFloat1257;
          if (f3 > f5) {
            f5 = 1;
            f3 = f5 / f3;
            f1 = f1 * f3;
            f0 = f0 * f3;
            heapClassInst.heapFloat[fp + numDefineNeg4] = f1;
            f2 = f2 * f3;
            heapClassInst.heapFloat[r2 + 1] = f0;
            heapClassInst.heapFloat[r2 + numDefine2] = f2;
            heapClassInst.heap32[r2 + numDefine3] = 0;
          } else {
            f1 = 1;
            f0 = 0;
            f2 = f0;
          }
          f1 = f1 * f6;
          f3 = heapClassInst.heapFloat[r0 + numDefine13];
          f5 = heapClassInst.heapFloat[r0 + numDefine15];
          f7 = heapClassInst.heapFloat[r0 + numDefine14];
          r0 = sp + numDefineNeg32;
          f0 = f0 * f6;
          f1 = f3 + f1;
          f2 = f2 * f6;
          r2 = r0 >> numDefine2;
          f0 = f7 + f0;
          heapClassInst.heapFloat[fp + numDefineNeg8] = f1;
          f1 = f5 + f2;
          heapClassInst.heapFloat[r2 + 1] = f0;
          heapClassInst.heapFloat[r2 + numDefine2] = f1;
          heapClassInst.heap32[r2 + numDefine3] = 0;
          r2 = heapClassInst.heap32[r4];
          r2 = r2 >> numDefine2;
          r2 = heapClassInst.heap32[r2 + numDefine4];
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r1;
          heapClassInst.heap32[g0 + numDefine2] = r0;
          heapClassInst.heapFloat[g0 + numDefine3] = f4;
          functionTable[r2 >> numDefine2](i7);
          r0 = heapClassInst.heap32[r4 + 1];
          if (r0 !== 0) {
            r1 = r0 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + numDefine279];
            if (r2 === 0) {
              break repeat1;
            } else {
              r1 = heapClassInst.heap32[r1 + numDefine277];
              r2 = heapClassInst.heap32[r4 + numDefine34];
              if (r1 === r2) {
                r1 = (r3 + numDefine8) | 0;
                r2 = (r3 + numDefine72) | 0;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = r2;
                zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
                return;
              } else {
                r1 = (r3 + numDefine72) | 0;
                r3 = (r3 + numDefine8) | 0;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                label = numDefine8;
                break repeat3;
              }
            }
          } else {
            label = numDefine3;
          }
        } else {
          r0 = heapClassInst.heap32[r4 + 1];
          if (r0 !== 0) {
            r1 = r0 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + numDefine279];
            if (r2 === 0) {
              break repeat1;
            } else {
              r1 = heapClassInst.heap32[r1 + numDefine277];
              r4 = heapClassInst.heap32[r4 + numDefine34];
              if (r1 === r4) {
                r4 = (r3 + numDefine8) | 0;
                r3 = (r3 + numDefine72) | 0;
              } else {
                r4 = (r3 + numDefine72) | 0;
                r3 = (r3 + numDefine8) | 0;
              }
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r4;
              label = numDefine8;
            }
          } else {
            label = numDefine3;
          }
        }
      } while (false);
      switch (label) {
        case numDefine8:
          heapClassInst.heap32[g0 + numDefine2] = r3;
          zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
          return;
        case numDefine3:
          r0 = twoEStr59;
          r3 = twoEStr160;
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r3;
          heapClassInst.heap32[g0 + numDefine2] = numDefine101;
          assertNew(i7);
          break;
        default:
          break;
      }
    }
  } while (false);
  return;
}

function zn32btSphereSphereCollisionAlgorithmD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv32btSphereSphereCollisionAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine8];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine3];
    if (!(r1 === 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      r4 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + numDefine4];
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r1;
      functionTable[r4 >> numDefine2](i7);
    }
  }
  r1 = ztv30btActivatingCollisionAlgorithm;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn32btSphereSphereCollisionAlgorithmD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv32btSphereSphereCollisionAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r0 = heapClassInst.heapU8[r0 + numDefine8];
  if (!(r0 === 0)) {
    r0 = heapClassInst.heap32[r2 + numDefine3];
    if (!(r0 === 0)) {
      r1 = heapClassInst.heap32[r2 + 1];
      r3 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine4];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      functionTable[r3 >> numDefine2](i7);
    }
  }
  r0 = ztv30btActivatingCollisionAlgorithm;
  r0 = (r0 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r0;
  return;
}

function zn34btSphereTriangleCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  f0 = 1;
  commonVariable.fg0 = f0;
  return;
}

function zn34btSphereTriangleCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine3];
  if (!(r2 === 0)) {
    r0 = heapClassInst.heapU8[r0 + numDefine8];
    if (!(r0 === 0)) {
      r0 = heapClassInst.heap32[fp + 1];
      r3 = r0 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine2];
      r5 = heapClassInst.heap32[r3 + 1];
      if (r4 === r5) {
        r6 = 1;
        r7 = r5 << 1;
        r7 = r5 === 0 ? r6 : r7;
        if (!(r4 >= r7)) {
          if (r7 !== 0) {
            r2 = gNumAlignedAllocs;
            r2 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r2];
            r8 = r7 << numDefine2;
            r4 = (r4 + 1) | 0;
            r8 = r8 | numDefine3;
            heapClassInst.heap32[r2] = r4;
            r2 = (r8 + numDefine16) | 0;
            heapClassInst.heap32[g0] = r2;
            mallocNew(i7);
            r2 = commonVariable.rg0;
            if (r2 !== 0) {
              r4 = 0;
              r8 = (r2 + numDefine4) | 0;
              r4 = (r4 - r8) | 0;
              r4 = r4 & numDefine15;
              r4 = (r2 + r4) | 0;
              r8 = (r4 + numDefine4) | 0;
              r4 = r4 >> numDefine2;
              heapClassInst.heap32[r4] = r2;
              r2 = r8;
            }
          } else {
            r2 = 0;
          }
          r4 = (r0 + numDefine12) | 0;
          if (r5 < 1) {
            r8 = r4 >> numDefine2;
            r9 = heapClassInst.heap32[r8];
          } else {
            r8 = 0;
            repeat15: while (true) {
              r9 = r4 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r10 = r8 << numDefine2;
              r11 = (r9 + r10) | 0;
              r11 = r11 >> numDefine2;
              r10 = (r2 + r10) | 0;
              r11 = heapClassInst.heap32[r11];
              r8 = (r8 + 1) | 0;
              r10 = r10 >> numDefine2;
              heapClassInst.heap32[r10] = r11;
              if (!(r5 !== r8)) {
                break repeat15;
              }
            }
            r4 = (r0 + numDefine12) | 0;
          }
          if (r9 !== 0) {
            r8 = heapClassInst.heapU8[r0 + numDefine16];
            if (r8 !== 0) {
              r5 = gNumAlignedFree;
              r5 = r5 >> numDefine2;
              r8 = heapClassInst.heap32[r5];
              r8 = (r8 + 1) | 0;
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r5] = r8;
              r5 = heapClassInst.heap32[r9 + -1];
              heapClassInst.heap32[g0] = r5;
              free(i7);
              r5 = heapClassInst.heap32[r3 + 1];
            }
            r8 = r4 >> numDefine2;
            heapClassInst.heap32[r8] = 0;
          }
          r4 = r4 >> numDefine2;
          heapClassInst.heap8[r0 + numDefine16] = r6;
          heapClassInst.heap32[r4] = r2;
          heapClassInst.heap32[r3 + numDefine2] = r7;
          r2 = heapClassInst.heap32[r1 + numDefine3];
        }
      }
      r0 = r5 << numDefine2;
      r1 = heapClassInst.heap32[r3 + numDefine3];
      r0 = (r1 + r0) | 0;
      r0 = r0 >> numDefine2;
      heapClassInst.heap32[r0] = r2;
      r0 = heapClassInst.heap32[r3 + 1];
      r0 = (r0 + 1) | 0;
      heapClassInst.heap32[r3 + 1] = r0;
    }
  }
  return;
}

function zn34btSphereTriangleCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg176;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine3];
  if (!(r2 === 0)) {
    r3 = heapClassInst.heap32[fp + 1];
    r4 = heapClassInst.heap32[fp + numDefine2];
    r5 = heapClassInst.heap32[fp + numDefine3];
    r6 = heapClassInst.heap32[fp + numDefine4];
    r7 = heapClassInst.heapU8[r0 + numDefine16];
    r8 = r7 === 0 ? r4 : r3;
    r3 = r7 === 0 ? r3 : r4;
    r4 = r8 >> numDefine2;
    r3 = r3 >> numDefine2;
    r7 = heapClassInst.heap32[r4 + numDefine48];
    r8 = heapClassInst.heap32[r3 + numDefine48];
    r9 = r6 >> numDefine2;
    heapClassInst.heap32[r9 + 1] = r2;
    r1 = heapClassInst.heap32[r1 + numDefine3];
    r1 = r1 >> numDefine2;
    f0 = heapClassInst.heapFloat[r1 + numDefine280];
    r1 = ztv22SphereTriangleDetector;
    r2 = sp + numDefineNeg16;
    r1 = (r1 + numDefine8) | 0;
    r10 = r2 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg4] = r1;
    heapClassInst.heap32[r10 + 1] = r8;
    r1 = sp + numDefineNeg152;
    heapClassInst.heap32[r10 + numDefine2] = r7;
    r7 = r1 >> numDefine2;
    heapClassInst.heapFloat[r10 + numDefine3] = f0;
    heapClassInst.heap32[r7 + numDefine33] = 0;
    heapClassInst.heap32[r7 + numDefine32] = numDefine44395;
    heapClassInst.heap32[fp + numDefineNeg38] = heapClassInst.heap32[r3 + 1];
    heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r3 + numDefine2];
    heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r3 + numDefine2];
    heapClassInst.heap32[r7 + numDefine3] = heapClassInst.heap32[r3 + numDefine4];
    heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r3 + numDefine5];
    heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r3 + numDefine6];
    heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r3 + numDefine7];
    heapClassInst.heap32[r7 + numDefine7] = heapClassInst.heap32[r3 + numDefine8];
    heapClassInst.heap32[r7 + numDefine8] = heapClassInst.heap32[r3 + numDefine9];
    heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r3 + numDefine10];
    heapClassInst.heap32[r7 + numDefine10] = heapClassInst.heap32[r3 + numDefine11];
    heapClassInst.heap32[r7 + numDefine11] = heapClassInst.heap32[r3 + numDefine12];
    heapClassInst.heap32[r7 + numDefine12] = heapClassInst.heap32[r3 + numDefine13];
    heapClassInst.heap32[r7 + numDefine13] = heapClassInst.heap32[r3 + numDefine14];
    heapClassInst.heap32[r7 + numDefine14] = heapClassInst.heap32[r3 + numDefine15];
    heapClassInst.heap32[r7 + numDefine15] = heapClassInst.heap32[r3 + numDefine16];
    heapClassInst.heap32[r7 + numDefine16] = heapClassInst.heap32[r4 + 1];
    heapClassInst.heap32[r7 + numDefine17] = heapClassInst.heap32[r4 + numDefine2];
    heapClassInst.heap32[r7 + numDefine18] = heapClassInst.heap32[r4 + numDefine3];
    heapClassInst.heap32[r7 + numDefine19] = heapClassInst.heap32[r4 + numDefine4];
    heapClassInst.heap32[r7 + numDefine20] = heapClassInst.heap32[r4 + numDefine5];
    heapClassInst.heap32[r7 + numDefine21] = heapClassInst.heap32[r4 + numDefine6];
    heapClassInst.heap32[r7 + numDefine22] = heapClassInst.heap32[r4 + numDefine7];
    heapClassInst.heap32[r7 + numDefine23] = heapClassInst.heap32[r4 + numDefine8];
    heapClassInst.heap32[r7 + numDefine24] = heapClassInst.heap32[r4 + numDefine9];
    heapClassInst.heap32[r7 + numDefine25] = heapClassInst.heap32[r4 + numDefine10];
    heapClassInst.heap32[r7 + numDefine26] = heapClassInst.heap32[r4 + numDefine11];
    heapClassInst.heap32[r7 + numDefine27] = heapClassInst.heap32[r4 + numDefine12];
    heapClassInst.heap32[r7 + numDefine28] = heapClassInst.heap32[r4 + numDefine13];
    heapClassInst.heap32[r7 + numDefine29] = heapClassInst.heap32[r4 + numDefine14];
    heapClassInst.heap32[r7 + numDefine30] = heapClassInst.heap32[r4 + numDefine15];
    heapClassInst.heap32[r7 + numDefine31] = heapClassInst.heap32[r4 + numDefine16];
    r3 = r5 >> numDefine2;
    r4 = heapClassInst.heapU8[r0 + numDefine16];
    r3 = heapClassInst.heap32[r3 + numDefine5];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = r6;
    heapClassInst.heap32[g0 + numDefine3] = r3;
    heapClassInst.heap32[g0 + numDefine4] = r4;
    zn22SphereTriangleDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(i7);
    r0 = heapClassInst.heapU8[r0 + numDefine8];
    if (!(r0 === 0)) {
      r0 = heapClassInst.heap32[r9 + 1];
      if (r0 !== 0) {
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine279];
        if (!(r2 === 0)) {
          r1 = heapClassInst.heap32[r1 + numDefine277];
          r2 = heapClassInst.heap32[r9 + numDefine34];
          if (r1 === r2) {
            r1 = (r6 + numDefine8) | 0;
            r2 = (r6 + numDefine72) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r2;
            zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
          } else {
            r1 = (r6 + numDefine72) | 0;
            r6 = (r6 + numDefine8) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r6;
            zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(i7);
            return;
          }
        }
      } else {
        r0 = twoEStr59;
        r6 = twoEStr160;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = numDefine101;
        assertNew(i7);
      }
    }
  }
  return;
}

function zn34btSphereTriangleCollisionAlgorithmD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv34btSphereTriangleCollisionAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine8];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine3];
    if (!(r1 === 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      r4 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + numDefine4];
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r1;
      functionTable[r4 >> numDefine2](i7);
    }
  }
  r1 = ztv30btActivatingCollisionAlgorithm;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn34btSphereTriangleCollisionAlgorithmD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv34btSphereTriangleCollisionAlgorithm;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r0 = heapClassInst.heapU8[r0 + numDefine8];
  if (!(r0 === 0)) {
    r0 = heapClassInst.heap32[r2 + numDefine3];
    if (!(r0 === 0)) {
      r1 = heapClassInst.heap32[r2 + 1];
      r3 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine4];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      functionTable[r3 >> numDefine2](i7);
    }
  }
  r0 = ztv30btActivatingCollisionAlgorithm;
  r0 = (r0 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r0;
  return;
}

function zn20btAlignedObjectArrayI9btElementE17quickSortInternalI31btUnionFindElementSortPredicateEEvTIi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = (r0 + r1) | 0;
  r3 = r2 >>> numDefine31;
  r4 = heapClassInst.heap32[fp];
  r2 = (r2 + r3) | 0;
  r3 = r4 >> numDefine2;
  r2 = r2 & numDefine41822;
  r5 = heapClassInst.heap32[r3 + numDefine3];
  r2 = r2 << numDefine2;
  r2 = (r5 + r2) | 0;
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r5 = r1;
  r6 = r0;
  repeat1: while (true) {
    r7 = heapClassInst.heap32[r3 + numDefine3];
    r8 = r5 << numDefine3;
    r8 = (r7 + r8) | 0;
    r8 = r8 >> numDefine2;
    r8 = heapClassInst.heap32[r8];
    if (r8 < r2) {
      repeat4: while (true) {
        r8 = r5 << numDefine3;
        r8 = (r7 + r8) | 0;
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine2];
        r5 = (r5 + 1) | 0;
        if (r8 < r2) {
          continue repeat4;
        } else {
          break repeat4;
        }
      }
    }
    r9 = r6 << numDefine3;
    r9 = (r7 + r9) | 0;
    r9 = r9 >> numDefine2;
    r9 = heapClassInst.heap32[r9];
    repeat7: do {
      if (r2 < r9) {
        repeat8: while (true) {
          r9 = r6 << numDefine3;
          r9 = (r7 + r9) | 0;
          r9 = r9 >> numDefine2;
          r9 = heapClassInst.heap32[r9 + numDefineNeg2];
          r6 = (r6 + -1) | 0;
          if (r2 < r9) {
            continue repeat8;
          } else {
            break repeat7;
          }
        }
      }
    } while (false);
    if (r5 <= r6) {
      r10 = r5 << numDefine3;
      r11 = r6 << numDefine3;
      r10 = (r7 + r10) | 0;
      r7 = (r7 + r11) | 0;
      r10 = r10 >> numDefine2;
      r7 = r7 >> numDefine2;
      r12 = heapClassInst.heap32[r10 + 1];
      r7 = heapClassInst.heap32[r7 + 1];
      heapClassInst.heap32[r10] = r9;
      heapClassInst.heap32[r10 + 1] = r7;
      r7 = heapClassInst.heap32[r3 + numDefine3];
      r7 = (r7 + r11) | 0;
      r7 = r7 >> numDefine2;
      r5 = (r5 + 1) | 0;
      r6 = (r6 + -1) | 0;
      heapClassInst.heap32[r7] = r8;
      heapClassInst.heap32[r7 + 1] = r12;
    }
    if (r5 <= r6) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  if (!(r6 <= r1)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = r6;
    zn20btAlignedObjectArrayI9btElementE17quickSortInternalI31btUnionFindElementSortPredicateEEvTIi(i7);
  }
  if (!(r5 >= r0)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r5;
    heapClassInst.heap32[g0 + numDefine2] = r0;
    zn20btAlignedObjectArrayI9btElementE17quickSortInternalI31btUnionFindElementSortPredicateEEvTIi(i7);
  }
  return;
}

function zn22SphereTriangleDetectorD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv22SphereTriangleDetector;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn22SphereTriangleDetectorD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv22SphereTriangleDetector;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn22SphereTriangleDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let f29: number = 0.0;
  let f30: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg144;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine2];
  r1 = r1 >> numDefine2;
  f0 = heapClassInst.heapFloat[r1 + numDefine19];
  f1 = heapClassInst.heapFloat[r1 + numDefine15];
  f2 = heapClassInst.heapFloat[r1 + numDefine23];
  f3 = heapClassInst.heapFloat[r1 + numDefine17];
  f4 = heapClassInst.heapFloat[r1 + numDefine13];
  f5 = heapClassInst.heapFloat[r1 + numDefine21];
  f6 = heapClassInst.heapFloat[r1 + numDefine22];
  f7 = heapClassInst.heapFloat[r1 + numDefine14];
  f8 = heapClassInst.heapFloat[r1 + numDefine18];
  f0 = f0 - f1;
  f6 = f6 - f7;
  f3 = f3 - f4;
  f1 = f2 - f1;
  f2 = f8 - f7;
  f4 = f5 - f4;
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[r0 + 1];
  f5 = f2 * f1;
  f7 = f0 * f6;
  f0 = f0 * f4;
  f1 = f3 * f1;
  r2 = r2 >> numDefine2;
  r3 = r3 >> numDefine2;
  f5 = f5 - f7;
  f0 = f0 - f1;
  f1 = f3 * f6;
  f2 = f2 * f4;
  f3 = heapClassInst.heapFloat[r0 + numDefine3];
  f1 = f1 - f2;
  f2 = f5 * f5;
  f4 = f0 * f0;
  f6 = heapClassInst.heapFloat[r3 + numDefine7];
  f7 = heapClassInst.heapFloat[r3 + numDefine3];
  f8 = heapClassInst.heapFloat[r2 + numDefine18];
  f9 = heapClassInst.heapFloat[r2 + numDefine22];
  f10 = heapClassInst.heapFloat[r2 + numDefine26];
  f11 = heapClassInst.heapFloat[r2 + numDefine17];
  f12 = heapClassInst.heapFloat[r2 + numDefine21];
  f13 = heapClassInst.heapFloat[r2 + numDefine25];
  f14 = heapClassInst.heapFloat[r2 + numDefine16];
  f15 = heapClassInst.heapFloat[r2 + numDefine12];
  f16 = heapClassInst.heapFloat[r2 + numDefine28];
  f17 = heapClassInst.heapFloat[r2 + numDefine20];
  f18 = heapClassInst.heapFloat[r2 + numDefine13];
  f19 = heapClassInst.heapFloat[r2 + numDefine29];
  f20 = heapClassInst.heapFloat[r2 + numDefine24];
  f21 = heapClassInst.heapFloat[r2 + numDefine14];
  f22 = heapClassInst.heapFloat[r2 + numDefine30];
  f2 = f2 + f4;
  f4 = f1 * f1;
  f15 = f15 - f16;
  f16 = f18 - f19;
  f2 = f2 + f4;
  f4 = f21 - f22;
  heapClassInst.heapFloat[g0] = f2;
  f2 = f11 * f15;
  f11 = f12 * f16;
  f12 = f14 * f15;
  f14 = f17 * f16;
  sqrtf(i7);
  f18 = 1;
  heapClassInst.heapFloat[fp + numDefineNeg25] = f18;
  f8 = f8 * f15;
  f9 = f9 * f16;
  f2 = f2 + f11;
  f11 = f13 * f4;
  f12 = f12 + f14;
  f13 = f20 * f4;
  f14 = f18 / commonVariable.fg0;
  f2 = f2 + f11;
  f11 = heapClassInst.heapFloat[r1 + numDefine14];
  f12 = f12 + f13;
  f13 = heapClassInst.heapFloat[r1 + numDefine13];
  f8 = f8 + f9;
  f4 = f10 * f4;
  f5 = f5 * f14;
  f9 = f12 - f13;
  heapClassInst.heapFloat[fp + numDefineNeg28] = f9;
  f0 = f0 * f14;
  f10 = f2 - f11;
  heapClassInst.heapFloat[fp + numDefineNeg29] = f10;
  f4 = f8 + f4;
  f8 = heapClassInst.heapFloat[r1 + numDefine15];
  f1 = f1 * f14;
  f14 = f4 - f8;
  heapClassInst.heapFloat[fp + numDefineNeg27] = f14;
  f9 = f9 * f5;
  f10 = f10 * f0;
  f9 = f9 + f10;
  f10 = f14 * f1;
  f9 = f9 + f10;
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = heapClassInst.heap32[fp + numDefine4];
  f6 = f6 * f7;
  heapClassInst.heapFloat[fp + numDefineNeg26] = f6;
  f6 = 0;
  if (f9 < f6) {
    f9 = -f9;
    f5 = -f5;
    f0 = -f0;
    f1 = -f1;
  }
  f7 = heapClassInst.heapFloat[fp + numDefineNeg26];
  if (f9 < f7) {
    label = numDefine4;
  } else {
    f7 = f5 * f6;
    f10 = f0 * f6;
    f7 = f7 + f10;
    f10 = f1 * f6;
    f7 = f7 + f10;
    if (f7 >= f6) {
      label = numDefine29;
    } else {
      label = numDefine4;
    }
  }
  repeat6: do {
    if (label === numDefine4) {
      f7 = heapClassInst.heapFloat[fp + numDefineNeg26];
      f3 = f7 + f3;
      heapClassInst.heapFloat[fp + numDefineNeg30] = f3;
      if (!(f3 <= f9)) {
        f3 = heapClassInst.heapFloat[r1 + numDefine19];
        f7 = heapClassInst.heapFloat[r1 + numDefine23];
        f10 = heapClassInst.heapFloat[r1 + numDefine17];
        f14 = heapClassInst.heapFloat[r1 + numDefine21];
        f15 = heapClassInst.heapFloat[r1 + numDefine18];
        f16 = heapClassInst.heapFloat[r1 + numDefine22];
        f17 = f7 - f3;
        f18 = f14 - f10;
        f19 = f3 - f8;
        f8 = f8 - f7;
        f20 = f16 - f15;
        f21 = f10 - f13;
        f22 = f15 - f11;
        f13 = f13 - f14;
        f11 = f11 - f16;
        f23 = f20 * f1;
        f24 = f17 * f0;
        f17 = f17 * f5;
        f25 = f18 * f1;
        f26 = f22 * f1;
        f27 = f19 * f0;
        f19 = f19 * f5;
        f28 = f21 * f1;
        f29 = f11 * f1;
        f30 = f8 * f0;
        f8 = f8 * f5;
        heapClassInst.heapFloat[fp + numDefineNeg31] = f8;
        f8 = f13 * f1;
        f23 = f23 - f24;
        f10 = f12 - f10;
        f17 = f17 - f25;
        f15 = f2 - f15;
        f18 = f18 * f0;
        f20 = f20 * f5;
        f24 = f26 - f27;
        f19 = f19 - f28;
        f21 = f21 * f0;
        f22 = f22 * f5;
        f25 = f29 - f30;
        f14 = f12 - f14;
        f26 = heapClassInst.heapFloat[fp + numDefineNeg31];
        f8 = f26 - f8;
        f16 = f2 - f16;
        f13 = f13 * f0;
        f11 = f11 * f5;
        f10 = f23 * f10;
        f15 = f17 * f15;
        f17 = f18 - f20;
        f3 = f4 - f3;
        f18 = heapClassInst.heapFloat[fp + numDefineNeg28];
        f18 = f24 * f18;
        f20 = heapClassInst.heapFloat[fp + numDefineNeg29];
        f19 = f19 * f20;
        f20 = f21 - f22;
        f14 = f25 * f14;
        f8 = f8 * f16;
        f11 = f13 - f11;
        f7 = f4 - f7;
        f10 = f10 + f15;
        f3 = f17 * f3;
        f13 = f18 + f19;
        f15 = heapClassInst.heapFloat[fp + numDefineNeg27];
        f15 = f20 * f15;
        f8 = f14 + f8;
        f7 = f11 * f7;
        f3 = f10 + f3;
        f10 = f13 + f15;
        f7 = f8 + f7;
        if (f3 <= f6) {
          label = numDefine8;
        } else {
          f8 = 0;
          if (f10 <= f8) {
            label = numDefine8;
          } else {
            if (f7 > f8) {
              label = numDefine11;
            } else {
              label = numDefine8;
            }
          }
        }
        repeat12: do {
          if (label === numDefine8) {
            if (!(f10 > f6)) {
              if (!(f3 > f6)) {
                if (!(f7 > f6)) {
                  label = numDefine11;
                  break repeat12;
                }
              }
            }
            r1 = heapClassInst.heap32[r0 + numDefine2];
            r5 = r1 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine22];
            heapClassInst.heap32[g0] = r1;
            functionTable[r5 >> numDefine2](i7);
            r1 = commonVariable.rg0;
            if (r1 < 1) {
              break repeat6;
            } else {
              f0 = heapClassInst.heapFloat[fp + numDefineNeg30];
              f5 = f0 * f0;
              r1 = 0;
              r5 = r1;
              repeat19: while (true) {
                r6 = heapClassInst.heap32[r0 + numDefine2];
                r7 = r6 >> numDefine2;
                r7 = heapClassInst.heap32[r7];
                r7 = r7 >> numDefine2;
                r7 = heapClassInst.heap32[r7 + numDefine23];
                r8 = sp + numDefineNeg32;
                r9 = sp + numDefineNeg16;
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = r9;
                heapClassInst.heap32[g0 + numDefine3] = r8;
                functionTable[r7 >> numDefine2](i7);
                r6 = r8 >> numDefine2;
                r7 = r9 >> numDefine2;
                f7 = heapClassInst.heapFloat[r7 + 1];
                f8 = heapClassInst.heapFloat[r6 + 1];
                f9 = heapClassInst.heapFloat[fp + numDefineNeg4];
                f10 = heapClassInst.heapFloat[fp + numDefineNeg8];
                f11 = f2 - f7;
                f8 = f8 - f7;
                f13 = f12 - f9;
                f10 = f10 - f9;
                f14 = heapClassInst.heapFloat[r7 + numDefine2];
                f15 = heapClassInst.heapFloat[r6 + numDefine2];
                f16 = f4 - f14;
                f15 = f15 - f14;
                f17 = f10 * f13;
                f18 = f8 * f11;
                f17 = f17 + f18;
                f18 = f15 * f16;
                f17 = f17 + f18;
                r1 = (r1 + 1) | 0;
                if (f17 > f6) {
                  f18 = f10 * f10;
                  f19 = f8 * f8;
                  f18 = f18 + f19;
                  f19 = f15 * f15;
                  f18 = f18 + f19;
                  if (f17 >= f18) {
                    f13 = f13 - f10;
                    f11 = f11 - f8;
                    f16 = f16 - f15;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg25];
                  } else {
                    f17 = f17 / f18;
                    f18 = f10 * f17;
                    f19 = f8 * f17;
                    f20 = f15 * f17;
                    f13 = f13 - f18;
                    f11 = f11 - f19;
                    f16 = f16 - f20;
                  }
                } else {
                  f17 = f6;
                }
                f13 = f13 * f13;
                f11 = f11 * f11;
                f11 = f13 + f11;
                f13 = f16 * f16;
                f11 = f11 + f13;
                if (f11 < f5) {
                  f0 = f10 * f17;
                  f3 = f8 * f17;
                  f8 = f15 * f17;
                  f1 = f9 + f0;
                  f0 = f7 + f3;
                  f3 = f14 + f8;
                  r5 = 1;
                }
                r6 = heapClassInst.heap32[r0 + numDefine2];
                r7 = r6 >> numDefine2;
                r7 = heapClassInst.heap32[r7];
                r7 = r7 >> numDefine2;
                r7 = heapClassInst.heap32[r7 + numDefine22];
                heapClassInst.heap32[g0] = r6;
                functionTable[r7 >> numDefine2](i7);
                r6 = commonVariable.rg0;
                if (!(r6 > r1)) {
                  break repeat19;
                }
              }
              r0 = r5 & numDefine255;
              if (r0 === 0) {
                break repeat6;
              } else {
                label = numDefine23;
              }
            }
          }
        } while (false);
        if (label === numDefine11) {
          f6 = f1 * f9;
          f0 = f0 * f9;
          f1 = f5 * f9;
          f3 = f4 - f6;
          f0 = f2 - f0;
          f1 = f12 - f1;
        }
        f2 = f2 - f0;
        f5 = f12 - f1;
        f4 = f4 - f3;
        f6 = f5 * f5;
        f7 = f2 * f2;
        f6 = f6 + f7;
        f7 = f4 * f4;
        f6 = f6 + f7;
        f7 = heapClassInst.heapFloat[fp + numDefineNeg26];
        f7 = f7 * f7;
        if (f7 <= f6) {
          f6 = 0;
          f5 = f5 * f6;
          f2 = f2 * f6;
          f2 = f5 + f2;
          f4 = f4 * f6;
          f2 = f2 + f4;
          if (f2 >= f6) {
            break repeat6;
          }
        } else {
          heapClassInst.heapFloat[g0] = f6;
          sqrtf(i7);
          f7 = commonVariable.fg0;
          heapClassInst.heapFloat[g0] = f6;
          f6 = 1;
          sqrtf(i7);
          f9 = heapClassInst.heapFloat[fp + numDefineNeg26];
          f7 = f9 - f7;
          f6 = f6 / commonVariable.fg0;
          f5 = f5 * f6;
          f2 = f2 * f6;
          f4 = f4 * f6;
          f6 = -f7;
        }
        if (r4 === 0) {
          r0 = r3 >> numDefine2;
          f7 = heapClassInst.heapFloat[r2 + numDefine16];
          f8 = heapClassInst.heapFloat[r2 + numDefine17];
          r0 = heapClassInst.heap32[r0];
          f9 = heapClassInst.heapFloat[r2 + numDefine20];
          f10 = heapClassInst.heapFloat[r2 + numDefine21];
          f11 = f7 * f1;
          f12 = f8 * f0;
          f13 = heapClassInst.heapFloat[r2 + numDefine18];
          r0 = r0 >> numDefine2;
          f14 = heapClassInst.heapFloat[r2 + numDefine24];
          f15 = heapClassInst.heapFloat[r2 + numDefine25];
          f16 = heapClassInst.heapFloat[r2 + numDefine22];
          f17 = f9 * f1;
          f18 = f10 * f0;
          f11 = f11 + f12;
          f12 = f13 * f3;
          f19 = heapClassInst.heapFloat[r2 + numDefine26];
          r0 = heapClassInst.heap32[r0 + numDefine4];
          f1 = f14 * f1;
          f0 = f15 * f0;
          f17 = f17 + f18;
          f18 = f16 * f3;
          f11 = f11 + f12;
          f12 = heapClassInst.heapFloat[r2 + numDefine28];
          f20 = heapClassInst.heapFloat[r2 + numDefine30];
          f21 = heapClassInst.heapFloat[r2 + numDefine29];
          r1 = sp + numDefineNeg64;
          f17 = f17 + f18;
          f0 = f1 + f0;
          f1 = f19 * f3;
          f3 = f11 + f12;
          f0 = f0 + f1;
          r2 = r1 >> numDefine2;
          f1 = f17 + f21;
          heapClassInst.heapFloat[fp + numDefineNeg16] = f3;
          f3 = f7 * f5;
          f7 = f8 * f2;
          f0 = f0 + f20;
          heapClassInst.heapFloat[r2 + 1] = f1;
          heapClassInst.heapFloat[r2 + numDefine2] = f0;
          f0 = f9 * f5;
          f1 = f10 * f2;
          f3 = f3 + f7;
          f7 = f13 * f4;
          r4 = sp + numDefineNeg48;
          f5 = f14 * f5;
          f2 = f15 * f2;
          f0 = f0 + f1;
          f1 = f16 * f4;
          f3 = f3 + f7;
          heapClassInst.heap32[r2 + numDefine3] = 0;
          r2 = r4 >> numDefine2;
          f2 = f5 + f2;
          f4 = f19 * f4;
          f0 = f0 + f1;
          heapClassInst.heapFloat[fp + numDefineNeg12] = f3;
          f1 = f2 + f4;
          heapClassInst.heapFloat[r2 + 1] = f0;
          heapClassInst.heapFloat[r2 + numDefine2] = f1;
          heapClassInst.heap32[r2 + numDefine3] = 0;
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r4;
          heapClassInst.heap32[g0 + numDefine2] = r1;
          heapClassInst.heapFloat[g0 + numDefine3] = f6;
          functionTable[r0 >> numDefine2](i7);
        } else {
          f7 = heapClassInst.heapFloat[r2 + numDefine16];
          f8 = heapClassInst.heapFloat[r2 + numDefine17];
          f9 = heapClassInst.heapFloat[r2 + numDefine20];
          f10 = heapClassInst.heapFloat[r2 + numDefine21];
          f11 = f7 * f5;
          f12 = f8 * f2;
          f13 = heapClassInst.heapFloat[r2 + numDefine18];
          f14 = heapClassInst.heapFloat[r2 + numDefine24];
          f15 = heapClassInst.heapFloat[r2 + numDefine25];
          f16 = heapClassInst.heapFloat[r2 + numDefine22];
          f17 = f9 * f5;
          f18 = f10 * f2;
          f11 = f11 + f12;
          f12 = f13 * f4;
          f19 = heapClassInst.heapFloat[r2 + numDefine26];
          f11 = f11 + f12;
          f5 = f14 * f5;
          f2 = f15 * f2;
          f12 = f17 + f18;
          f17 = f16 * f4;
          r0 = sp + numDefineNeg80;
          f12 = f12 + f17;
          f2 = f5 + f2;
          f4 = f19 * f4;
          f5 = -f11;
          f2 = f2 + f4;
          r1 = r0 >> numDefine2;
          f4 = -f12;
          heapClassInst.heapFloat[fp + numDefineNeg20] = f5;
          f5 = -f2;
          heapClassInst.heapFloat[r1 + 1] = f4;
          heapClassInst.heapFloat[r1 + numDefine2] = f5;
          f4 = f7 * f1;
          f5 = f8 * f0;
          heapClassInst.heap32[r1 + numDefine3] = 0;
          f7 = f9 * f1;
          f8 = f10 * f0;
          f4 = f4 + f5;
          f5 = f13 * f3;
          f1 = f14 * f1;
          f0 = f15 * f0;
          f7 = f7 + f8;
          f8 = f16 * f3;
          f4 = f4 + f5;
          f5 = heapClassInst.heapFloat[r2 + numDefine28];
          f0 = f1 + f0;
          f1 = f19 * f3;
          f3 = f7 + f8;
          f7 = heapClassInst.heapFloat[r2 + numDefine29];
          f8 = heapClassInst.heapFloat[r2 + numDefine30];
          f4 = f4 + f5;
          f5 = f11 * f6;
          r2 = sp + numDefineNeg96;
          f0 = f0 + f1;
          f1 = f3 + f7;
          f3 = f12 * f6;
          f4 = f4 + f5;
          r1 = r2 >> numDefine2;
          f0 = f0 + f8;
          f2 = f2 * f6;
          f1 = f1 + f3;
          heapClassInst.heapFloat[fp + numDefineNeg24] = f4;
          f0 = f0 + f2;
          heapClassInst.heapFloat[r1 + 1] = f1;
          heapClassInst.heapFloat[r1 + numDefine2] = f0;
          r4 = r3 >> numDefine2;
          heapClassInst.heap32[r1 + numDefine3] = 0;
          r1 = heapClassInst.heap32[r4];
          r1 = r1 >> numDefine2;
          r1 = heapClassInst.heap32[r1 + numDefine4];
          heapClassInst.heap32[g0] = r3;
          heapClassInst.heap32[g0 + 1] = r0;
          heapClassInst.heap32[g0 + numDefine2] = r2;
          heapClassInst.heapFloat[g0 + numDefine3] = f6;
          functionTable[r1 >> numDefine2](i7);
          return;
        }
      }
    }
  } while (false);
  return;
}

function znk10btBoxShape7getAabbERK11btTransformR9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f1 = heapClassInst.heapFloat[r1 + numDefine7];
  f2 = heapClassInst.heapFloat[r1 + numDefine8];
  f3 = heapClassInst.heapFloat[r1 + numDefine9];
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heapFloat[g0] = f1;
  heapClassInst.heapFloat[g0 + 1] = f2;
  heapClassInst.heapFloat[g0 + numDefine2] = f3;
  heapClassInst.heapFloat[g0 + numDefine3] = commonVariable.fg0;
  heapClassInst.heap32[g0 + numDefine4] = r0;
  heapClassInst.heap32[g0 + numDefine5] = r1;
  heapClassInst.heap32[g0 + numDefine6] = r2;
  z15btTransformAabbRK9btVector3fRK11btTransformRSS5(i7);
  return;
}

function z15btTransformAabbRK9btVector3fRK11btTransformRSS5(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine4];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[fp + numDefine2];
  f1 = heapClassInst.heapFloat[fp + numDefine3];
  f2 = heapClassInst.heapFloat[fp + 1];
  f3 = heapClassInst.heapFloat[fp];
  f4 = heapClassInst.heapFloat[r0 + numDefine10];
  r1 = heapClassInst.heap32[fp + numDefine5];
  r2 = heapClassInst.heap32[fp + numDefine6];
  f0 = f0 + f1;
  f2 = f2 + f1;
  f1 = f3 + f1;
  f3 = 0;
  if (f4 < f3) {
    f4 = -f4;
  }
  f5 = heapClassInst.heapFloat[r0 + numDefine9];
  if (f5 < f3) {
    f5 = -f5;
  }
  f6 = heapClassInst.heapFloat[r0 + numDefine8];
  if (f6 < f3) {
    f6 = -f6;
  }
  f7 = heapClassInst.heapFloat[r0 + numDefine6];
  if (f7 < f3) {
    f7 = -f7;
  }
  f8 = heapClassInst.heapFloat[r0 + numDefine5];
  if (f8 < f3) {
    f8 = -f8;
  }
  f9 = heapClassInst.heapFloat[r0 + numDefine4];
  if (f9 < f3) {
    f9 = -f9;
  }
  f10 = heapClassInst.heapFloat[r0 + numDefine2];
  if (f10 < f3) {
    f10 = -f10;
  }
  f11 = heapClassInst.heapFloat[r0 + 1];
  if (f11 < f3) {
    f11 = -f11;
  }
  f12 = heapClassInst.heapFloat[r0];
  if (f12 < f3) {
    f12 = -f12;
  }
  f3 = f12 * f1;
  f11 = f11 * f2;
  f9 = f9 * f1;
  f8 = f8 * f2;
  f3 = f3 + f11;
  f10 = f10 * f0;
  f1 = f6 * f1;
  f2 = f5 * f2;
  f5 = f9 + f8;
  f6 = f7 * f0;
  f3 = f3 + f10;
  f7 = heapClassInst.heapFloat[r0 + numDefine12];
  f8 = heapClassInst.heapFloat[r0 + numDefine13];
  f9 = heapClassInst.heapFloat[r0 + numDefine14];
  f5 = f5 + f6;
  r0 = r1 >> numDefine2;
  f1 = f1 + f2;
  f0 = f4 * f0;
  f2 = f7 - f3;
  f0 = f1 + f0;
  f1 = f8 - f5;
  heapClassInst.heapFloat[r0] = f2;
  f2 = f9 - f0;
  heapClassInst.heapFloat[r0 + 1] = f1;
  heapClassInst.heapFloat[r0 + numDefine2] = f2;
  r1 = r2 >> numDefine2;
  f1 = f7 + f3;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  f2 = f8 + f5;
  heapClassInst.heapFloat[r1] = f1;
  f0 = f9 + f0;
  heapClassInst.heapFloat[r1 + 1] = f2;
  heapClassInst.heapFloat[r1 + numDefine2] = f0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  return;
}

function znk10btBoxShape24localGetSupportingVertexERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  f0 = heapClassInst.heapFloat[r1 + numDefine7];
  f1 = heapClassInst.heapFloat[r1 + numDefine8];
  f2 = heapClassInst.heapFloat[r1 + numDefine9];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f3 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f4 = commonVariable.fg0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  r0 = heapClassInst.heap32[fp + numDefine2];
  functionTable[r1 >> numDefine2](i7);
  r0 = r0 >> numDefine2;
  f0 = f0 + commonVariable.fg0;
  r1 = heapClassInst.heap32[fp];
  f1 = f1 + f4;
  f4 = 0;
  f5 = -f0;
  f6 = heapClassInst.heapFloat[r0];
  f7 = heapClassInst.heapFloat[r0 + numDefine2];
  f8 = heapClassInst.heapFloat[r0 + 1];
  f2 = f2 + f3;
  f3 = -f1;
  r0 = r1 >> numDefine2;
  f0 = f6 < f4 ? f5 : f0;
  f5 = -f2;
  f1 = f8 < f4 ? f3 : f1;
  heapClassInst.heapFloat[r0] = f0;
  f0 = f7 < f4 ? f5 : f2;
  heapClassInst.heapFloat[r0 + 1] = f1;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk10btBoxShape37localGetSupportingVertexWithoutMarginERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + numDefine2];
  r1 = r1 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine7];
  r2 = heapClassInst.heap32[fp];
  f1 = heapClassInst.heapFloat[r0 + numDefine9];
  f2 = heapClassInst.heapFloat[r0 + numDefine8];
  f3 = 0;
  f4 = -f0;
  f5 = heapClassInst.heapFloat[r1];
  f6 = heapClassInst.heapFloat[r1 + numDefine2];
  f7 = heapClassInst.heapFloat[r1 + 1];
  f8 = -f2;
  r0 = r2 >> numDefine2;
  f0 = f5 < f3 ? f4 : f0;
  f4 = -f1;
  f2 = f7 < f3 ? f8 : f2;
  heapClassInst.heapFloat[r0] = f0;
  f0 = f6 < f3 ? f4 : f1;
  heapClassInst.heapFloat[r0 + 1] = f2;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk10btBoxShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine3];
  if (!(r0 < 1)) {
    r1 = heapClassInst.heap32[fp];
    r2 = heapClassInst.heap32[fp + 1];
    r3 = heapClassInst.heap32[fp + numDefine2];
    r3 = (r3 + numDefine8) | 0;
    r2 = (r2 + numDefine8) | 0;
    f3 = 0;
    repeat3: while (true) {
      r4 = r1 >> numDefine2;
      r5 = r2 >> numDefine2;
      f0 = heapClassInst.heapFloat[r4 + numDefine7];
      f1 = heapClassInst.heapFloat[r4 + numDefine9];
      f2 = heapClassInst.heapFloat[r4 + numDefine8];
      f4 = -f0;
      f5 = heapClassInst.heapFloat[r5 + numDefineNeg2];
      f6 = heapClassInst.heapFloat[r5];
      f7 = heapClassInst.heapFloat[r5 + -1];
      f8 = -f2;
      r4 = r3 >> numDefine2;
      f0 = f5 < f3 ? f4 : f0;
      f4 = -f1;
      f2 = f7 < f3 ? f8 : f2;
      heapClassInst.heapFloat[r4 + numDefineNeg2] = f0;
      f0 = f6 < f3 ? f4 : f1;
      heapClassInst.heapFloat[r4 + -1] = f2;
      r0 = (r0 + -1) | 0;
      r3 = (r3 + numDefine16) | 0;
      r2 = (r2 + numDefine16) | 0;
      heapClassInst.heapFloat[r4] = f0;
      heapClassInst.heap32[r4 + 1] = 0;
      if (r0 !== 0) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function zn10btBoxShape9setMarginEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f1 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f2 = commonVariable.fg0;
  f3 = heapClassInst.heapFloat[r1 + numDefine9];
  f4 = heapClassInst.heapFloat[r1 + numDefine8];
  f5 = heapClassInst.heapFloat[r1 + numDefine7];
  heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f6 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f7 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  f2 = f5 + f2;
  functionTable[r2 >> numDefine2](i7);
  f1 = f4 + f1;
  f2 = f2 - commonVariable.fg0;
  f0 = f3 + f0;
  f1 = f1 - f7;
  heapClassInst.heapFloat[r1 + numDefine7] = f2;
  f0 = f0 - f6;
  heapClassInst.heapFloat[r1 + numDefine8] = f1;
  heapClassInst.heapFloat[r1 + numDefine9] = f0;
  heapClassInst.heap32[r1 + numDefine10] = 0;
  return;
}

function znk10btBoxShape8getPlaneER9btVector3S1I(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg64;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine28];
  r3 = sp + numDefineNeg32;
  r4 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  functionTable[r2 >> numDefine2](i7);
  r2 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[fp + 1];
  f0 = heapClassInst.heapFloat[r2 + numDefine2];
  f1 = heapClassInst.heapFloat[r2 + 1];
  f2 = heapClassInst.heapFloat[fp + numDefineNeg8];
  r2 = r3 >> numDefine2;
  heapClassInst.heapFloat[r2] = f2;
  heapClassInst.heapFloat[r2 + 1] = f1;
  heapClassInst.heapFloat[r2 + numDefine2] = f0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine15];
  r2 = sp + numDefineNeg16;
  f2 = -f2;
  r3 = r2 >> numDefine2;
  f1 = -f1;
  heapClassInst.heapFloat[fp + numDefineNeg4] = f2;
  f0 = -f0;
  heapClassInst.heapFloat[r3 + 1] = f1;
  heapClassInst.heapFloat[r3 + numDefine2] = f0;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  r3 = sp + numDefineNeg48;
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r0 = r0 >> numDefine2;
  functionTable[r1 >> numDefine2](i7);
  r1 = r3 >> numDefine2;
  heapClassInst.heap32[r0] = heapClassInst.heap32[fp + numDefineNeg12];
  heapClassInst.heap32[r0 + 1] = heapClassInst.heap32[r1 + 1];
  heapClassInst.heap32[r0 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
  heapClassInst.heap32[r0 + numDefine3] = heapClassInst.heap32[r1 + numDefine3];
  return;
}

function znk10btBoxShape12getNumPlanesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine6;
  commonVariable.rg0 = r0;
  return;
}

function znk10btBoxShape14getNumVerticesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine8;
  commonVariable.rg0 = r0;
  return;
}

function znk10btBoxShape11getNumEdgesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine12;
  commonVariable.rg0 = r0;
  return;
}

function znk10btBoxShape9getVertexEiR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >>> 1;
  r2 = heapClassInst.heap32[fp];
  r2 = r2 >> numDefine2;
  r1 = r1 & 1;
  r3 = r0 >>> numDefine2;
  r0 = r0 & 1;
  r4 = 0;
  f0 = 1;
  f1 = 0;
  r3 = r3 & 1;
  r5 = r1 ^ 1;
  f0 = r0 === r4 ? f0 : f1;
  f1 = heapClassInst.heapFloat[r2 + numDefine7];
  f2 = r0;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r4 = r3 ^ 1;
  f3 = r5;
  f4 = heapClassInst.heapFloat[r2 + numDefine8];
  f5 = r1;
  f6 = heapClassInst.heapFloat[r2 + numDefine9];
  f0 = f1 * f0;
  f1 = f1 * f2;
  f2 = r4;
  f7 = r3;
  r0 = r0 >> numDefine2;
  f3 = f4 * f3;
  f4 = f4 * f5;
  f0 = f0 - f1;
  f1 = f6 * f2;
  f2 = f6 * f7;
  f3 = f3 - f4;
  heapClassInst.heapFloat[r0] = f0;
  f0 = f1 - f2;
  heapClassInst.heapFloat[r0 + 1] = f3;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk10btBoxShape8isInsideERK9btVector3f(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r1 = r1 >> numDefine2;
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0];
  f1 = heapClassInst.heapFloat[fp + numDefine2];
  f2 = heapClassInst.heapFloat[r1 + numDefine7];
  f3 = f2 + f1;
  if (!(f0 > f3)) {
    f2 = -f2;
    f2 = f2 - f1;
    if (!(f0 < f2)) {
      f0 = heapClassInst.heapFloat[r1 + numDefine8];
      f2 = heapClassInst.heapFloat[r0 + 1];
      f3 = f0 + f1;
      if (!(f2 > f3)) {
        f0 = -f0;
        f0 = f0 - f1;
        if (!(f2 < f0)) {
          f0 = heapClassInst.heapFloat[r1 + numDefine9];
          f2 = heapClassInst.heapFloat[r0 + numDefine2];
          f3 = f0 + f1;
          if (!(f2 > f3)) {
            f0 = -f0;
            f0 = f0 - f1;

            r0 = f2 >= f0 ? 1 : 0;
            r0 = r0 & 1;
            commonVariable.rg0 = r0;
            return;
          }
        }
      }
    }
  }
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znk10btBoxShape7getNameEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr173;
  commonVariable.rg0 = r0;
  return;
}

function znk10btBoxShape36getNumPreferredPenetrationDirectionsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine6;
  commonVariable.rg0 = r0;
  return;
}

function znk10btBoxShape21calculateLocalInertiaEfR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  f0 = heapClassInst.heapFloat[r1 + numDefine7];
  f1 = heapClassInst.heapFloat[r1 + numDefine8];
  f2 = heapClassInst.heapFloat[r1 + numDefine9];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f3 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  f1 = f1 + commonVariable.fg0;
  f2 = f2 + f3;
  functionTable[r1 >> numDefine2](i7);
  f0 = f0 + commonVariable.fg0;
  f1 = f1 + f1;
  f2 = f2 + f2;
  f0 = f0 + f0;
  f3 = heapClassInst.heapFloat[fp + 1];
  f4 = numDefine12;
  f1 = f1 * f1;
  f2 = f2 * f2;
  f0 = f0 * f0;
  r0 = heapClassInst.heap32[fp + numDefine2];
  f3 = f3 / f4;
  f4 = f1 + f2;
  f2 = f0 + f2;
  r0 = r0 >> numDefine2;
  f4 = f3 * f4;
  f0 = f0 + f1;
  f1 = f3 * f2;
  heapClassInst.heapFloat[r0] = f4;
  f0 = f3 * f0;
  heapClassInst.heapFloat[r0 + 1] = f1;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk10btBoxShape16getPlaneEquationER9btVector4i(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp + 1];
  f0 = heapClassInst.heapFloat[r0 + numDefine8];
  repeat1: do {
    if (r1 > numDefine2) {
      if (r1 === numDefine3) {
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r2] = 0;
        heapClassInst.heap32[r2 + 1] = numDefineNeg30432;
        label = numDefine11;
        break repeat1;
      } else {
        f0 = heapClassInst.heapFloat[r0 + numDefine9];
        if (r1 === numDefine4) {
          r2 = r2 >> numDefine2;
          heapClassInst.heap32[r2] = 0;
          heapClassInst.heap32[r2 + 1] = 0;
          f0 = -f0;
          heapClassInst.heap32[r2 + numDefine2] = numDefine53216;
          heapClassInst.heapFloat[r2 + numDefine3] = f0;
          return;
        } else {
          if (r1 === numDefine5) {
            r0 = r2 >> numDefine2;
            heapClassInst.heap32[r0] = 0;
            heapClassInst.heap32[r0 + 1] = 0;
            f0 = -f0;
            heapClassInst.heap32[r0 + numDefine2] = numDefineNeg30432;
            heapClassInst.heapFloat[r0 + numDefine3] = f0;
            return;
          } else {
            label = numDefine16;
            break repeat1;
          }
        }
      }
    } else {
      f1 = heapClassInst.heapFloat[r0 + numDefine7];
      if (r1 === 0) {
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r2] = numDefine53216;
      } else {
        if (r1 === 1) {
          r2 = r2 >> numDefine2;
          heapClassInst.heap32[r2] = numDefineNeg30432;
        } else {
          if (r1 === numDefine2) {
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = 0;
            heapClassInst.heap32[r2 + 1] = numDefine53216;
            label = numDefine11;
            break repeat1;
          } else {
            label = numDefine16;
            break repeat1;
          }
        }
      }
      heapClassInst.heap32[r2 + 1] = 0;
      f0 = -f1;
      label = numDefine12;
    }
  } while (false);
  switch (label) {
    case numDefine11:
      f0 = -f0;
      break;
    case numDefine16:
      r0 = twoEStr10;
      r1 = twoEStr2175;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine182;
      assertNew(i7);
      break;
    default:
      break;
  }
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heapFloat[r2 + numDefine3] = f0;
  return;
}

function znk10btBoxShape7getEdgeEiR9btVector3S1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  repeat1: do {
    if (r0 > numDefine5) {
      if (r0 > numDefine8) {
        if (r0 === numDefine9) {
          r0 = numDefine4;
          r4 = numDefine6;
          label = numDefine28;
          break repeat1;
        } else {
          if (r0 === numDefine10) {
            r0 = numDefine5;
            r4 = numDefine7;
            label = numDefine28;
            break repeat1;
          } else {
            if (r0 === numDefine11) {
              r0 = numDefine6;
              r4 = numDefine7;
              label = numDefine28;
              break repeat1;
            } else {
              label = numDefine27;
              break repeat1;
            }
          }
        }
      } else {
        if (r0 === numDefine6) {
          r0 = numDefine2;
          r4 = numDefine6;
          label = numDefine28;
          break repeat1;
        } else {
          if (r0 === numDefine7) {
            r0 = numDefine3;
            r4 = numDefine7;
            label = numDefine28;
            break repeat1;
          } else {
            if (r0 === numDefine8) {
              r0 = numDefine4;
              r4 = numDefine5;
              label = numDefine28;
              break repeat1;
            } else {
              label = numDefine27;
              break repeat1;
            }
          }
        }
      }
    } else {
      if (r0 > numDefine2) {
        if (r0 === numDefine3) {
          r0 = numDefine2;
          r4 = numDefine3;
          label = numDefine28;
          break repeat1;
        } else {
          if (r0 === numDefine4) {
            r0 = 0;
            r4 = numDefine4;
            label = numDefine28;
            break repeat1;
          } else {
            if (r0 === numDefine5) {
              r0 = 1;
              r4 = numDefine5;
              label = numDefine28;
              break repeat1;
            } else {
              label = numDefine27;
              break repeat1;
            }
          }
        }
      } else {
        if (r0 === 0) {
          r0 = 0;
          r4 = 1;
          label = numDefine28;
          break repeat1;
        } else {
          if (r0 === 1) {
            r0 = 0;
            r4 = numDefine2;
            label = numDefine28;
          } else {
            if (r0 === numDefine2) {
              r0 = 1;
              r4 = numDefine3;
              label = numDefine28;
            } else {
              label = numDefine27;
            }
          }
        }
      }
    }
  } while (false);
  switch (label) {
    case numDefine28:
      r5 = r1 >> numDefine2;
      r6 = heapClassInst.heap32[r5];
      r6 = r6 >> numDefine2;
      r6 = heapClassInst.heap32[r6 + numDefine24];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      heapClassInst.heap32[g0 + numDefine2] = r2;
      functionTable[r6 >> numDefine2](i7);
      r0 = heapClassInst.heap32[r5];
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0 + numDefine24];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r4;
      heapClassInst.heap32[g0 + numDefine2] = r3;
      functionTable[r0 >> numDefine2](i7);
      return;
    case numDefine27:
      r0 = twoEStr10;
      r1 = twoEStr2175;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine246;
      assertNew(i7);
      break;
    default:
      break;
  }
}

function znk10btBoxShape32getPreferredPenetrationDirectionEiR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp + numDefine2];
  repeat1: do {
    if (r0 > numDefine2) {
      if (r0 === numDefine3) {
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r1] = 0;
        heapClassInst.heap32[r1 + 1] = numDefineNeg30432;
        label = numDefine9;
        break repeat1;
      } else {
        if (r0 === numDefine4) {
          r1 = r1 >> numDefine2;
          heapClassInst.heap32[r1] = 0;
          heapClassInst.heap32[r1 + 1] = 0;
          heapClassInst.heap32[r1 + numDefine2] = numDefine53216;
          heapClassInst.heap32[r1 + numDefine3] = 0;
          return;
        } else {
          if (r0 === numDefine5) {
            r0 = r1 >> numDefine2;
            heapClassInst.heap32[r0] = 0;
            heapClassInst.heap32[r0 + 1] = 0;
            heapClassInst.heap32[r0 + numDefine2] = numDefineNeg30432;
            heapClassInst.heap32[r0 + numDefine3] = 0;
            return;
          } else {
            label = numDefine15;
            break repeat1;
          }
        }
      }
    } else {
      if (r0 === 0) {
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r1] = numDefine53216;
      } else {
        if (r0 === 1) {
          r1 = r1 >> numDefine2;
          heapClassInst.heap32[r1] = numDefineNeg30432;
        } else {
          if (r0 === numDefine2) {
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r1] = 0;
            heapClassInst.heap32[r1 + 1] = numDefine53216;
            label = numDefine9;
            break repeat1;
          } else {
            label = numDefine15;
            break repeat1;
          }
        }
      }
      heapClassInst.heap32[r1 + 1] = 0;
      label = numDefine9;
    }
  } while (false);
  switch (label) {
    case numDefine9:
      heapClassInst.heap32[r1 + numDefine2] = 0;
      heapClassInst.heap32[r1 + numDefine3] = 0;
      return;
    case numDefine15:
      r0 = twoEStr10;
      r1 = twoEStr2175;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine309;
      assertNew(i7);
      break;
    default:
      break;
  }
}

function zn10btBoxShape15setLocalScalingERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f1 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f2 = commonVariable.fg0;
  r0 = heapClassInst.heap32[fp + 1];
  f3 = heapClassInst.heapFloat[r1 + numDefine9];
  f4 = heapClassInst.heapFloat[r1 + numDefine8];
  f5 = heapClassInst.heapFloat[r1 + numDefine7];
  r0 = r0 >> numDefine2;
  f3 = f3 + f0;
  f6 = heapClassInst.heapFloat[r1 + numDefine5];
  f4 = f4 + f1;
  f7 = heapClassInst.heapFloat[r1 + numDefine4];
  f5 = f5 + f2;
  f8 = heapClassInst.heapFloat[r1 + numDefine3];
  f9 = heapClassInst.heapFloat[r0 + numDefine2];
  f3 = f3 / f6;
  f4 = f4 / f7;
  f5 = f5 / f8;
  f6 = 0;
  if (f9 < f6) {
    f9 = -f9;
  }
  f7 = heapClassInst.heapFloat[r0 + 1];
  if (f7 < f6) {
    f7 = -f7;
  }
  f8 = heapClassInst.heapFloat[r0];
  if (f8 < f6) {
    f8 = -f8;
  }
  heapClassInst.heapFloat[r1 + numDefine3] = f8;
  heapClassInst.heapFloat[r1 + numDefine4] = f7;
  heapClassInst.heapFloat[r1 + numDefine5] = f9;
  f5 = f5 * f8;
  f4 = f4 * f7;
  f2 = f5 - f2;
  heapClassInst.heap32[r1 + numDefine6] = 0;
  f3 = f3 * f9;
  f1 = f4 - f1;
  heapClassInst.heapFloat[r1 + numDefine7] = f2;
  f0 = f3 - f0;
  heapClassInst.heapFloat[r1 + numDefine8] = f1;
  heapClassInst.heapFloat[r1 + numDefine9] = f0;
  heapClassInst.heap32[r1 + numDefine10] = 0;
  return;
}

function zn10btBoxShapeD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  if (!(r0 === 0)) {
    r0 = gNumAlignedFree;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0];
    r1 = (r1 + 1) | 0;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r2 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}

function zn10btBoxShapeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function znk14btConcaveShape9getMarginEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine3];
  commonVariable.fg0 = f0;
  return;
}

function zn14btConcaveShape9setMarginEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine3] = heapClassInst.heap32[fp + 1];
  return;
}

function znk22btBvhTriangleMeshShape7getNameEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr181;
  commonVariable.rg0 = r0;
  return;
}

function znk22btBvhTriangleMeshShape28calculateSerializeBufferSizeEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine60;
  commonVariable.rg0 = r0;
  return;
}

function zzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallbackD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallbackD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallback11processNodeEii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg120;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + 1];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = sp + numDefineNeg52;
  r5 = sp + numDefineNeg56;
  r6 = sp + numDefineNeg60;
  r7 = sp + numDefineNeg64;
  r8 = sp + numDefineNeg68;
  r9 = sp + numDefineNeg72;
  r10 = sp + numDefineNeg76;
  r11 = sp + numDefineNeg80;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  heapClassInst.heap32[g0 + numDefine3] = r6;
  heapClassInst.heap32[g0 + numDefine4] = r7;
  heapClassInst.heap32[g0 + numDefine5] = r8;
  heapClassInst.heap32[g0 + numDefine6] = r9;
  heapClassInst.heap32[g0 + numDefine7] = r10;
  heapClassInst.heap32[g0 + numDefine8] = r11;
  heapClassInst.heap32[g0 + numDefine9] = r3;
  functionTable[r2 >> numDefine2](i7);
  r1 = heapClassInst.heap32[fp + numDefineNeg20];
  r2 = (r1 + numDefineNeg2) | 0;
  if (uint(r2) < uint(numDefine2)) {
    r2 = heapClassInst.heap32[fp + numDefine2];
    r4 = heapClassInst.heap32[fp + numDefineNeg17];
    r5 = heapClassInst.heap32[fp + numDefineNeg18];
    r5 = (r5 * r2) | 0;
    r6 = heapClassInst.heap32[r0 + 1];
    r4 = (r4 + r5) | 0;
    r5 = numDefineNeg6;
    repeat3: while (true) {
      r7 = 0;
      r8 = r5 << 1;
      r7 = (r7 - r8) | 0;
      if (r1 !== numDefine3) {
        r8 = (r4 - r8) | 0;
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + -1];
      } else {
        r8 = (r4 - r5) | 0;
        r8 = heapClassInst.heapU16[(r8 + numDefineNeg2) >> 1];
      }
      r9 = heapClassInst.heap32[fp + numDefineNeg16];
      r10 = heapClassInst.heap32[fp + numDefineNeg13];
      r8 = (r9 * r8) | 0;
      r9 = heapClassInst.heap32[fp + numDefineNeg15];
      if (r9 !== 0) {
        r9 = (r10 + r8) | 0;
        r11 = r6 >> numDefine2;
        f0 = llvmReadDouble(r9 + numDefine16);
        f1 = llvmReadDouble(r9 + numDefine8);
        f2 = llvmReadDouble(r10 + r8);
        f0 = f0;
        f3 = heapClassInst.heapFloat[r11 + numDefine3];
        f1 = f1;
        f4 = heapClassInst.heapFloat[r11 + numDefine2];
        f2 = f2;
        f5 = heapClassInst.heapFloat[r11 + 1];
        f0 = f0 * f3;
        f1 = f1 * f4;
        f2 = f2 * f5;
      } else {
        r8 = (r10 + r8) | 0;
        r8 = r8 >> numDefine2;
        r10 = r6 >> numDefine2;
        f0 = heapClassInst.heapFloat[r8 + numDefine2];
        f1 = heapClassInst.heapFloat[r10 + numDefine3];
        f2 = heapClassInst.heapFloat[r8 + 1];
        f3 = heapClassInst.heapFloat[r10 + numDefine2];
        f4 = heapClassInst.heapFloat[r8];
        f5 = heapClassInst.heapFloat[r10 + 1];
        f0 = f0 * f1;
        f1 = f2 * f3;
        f2 = f4 * f5;
      }
      r8 = sp + numDefineNeg48;
      r9 = r7 << numDefine2;
      r10 = r7 << numDefine2;
      r9 = (r8 + r9) | 0;
      r11 = r7 << numDefine2;
      r10 = (r8 + r10) | 0;
      r9 = r9 >> numDefine2;
      r7 = r7 << numDefine2;
      r11 = (r8 + r11) | 0;
      r10 = r10 >> numDefine2;
      heapClassInst.heapFloat[r9 + numDefineNeg4] = f2;
      r7 = (r8 + r7) | 0;
      r9 = r11 >> numDefine2;
      heapClassInst.heapFloat[r10 + numDefineNeg3] = f1;
      r5 = (r5 + numDefine2) | 0;
      r7 = r7 >> numDefine2;
      heapClassInst.heapFloat[r9 + numDefineNeg2] = f0;
      heapClassInst.heap32[r7 + -1] = 0;
      if (!(r5 !== 0)) {
        break repeat3;
      }
    }
    r1 = heapClassInst.heap32[r0 + numDefine2];
    r4 = r1 >> numDefine2;
    r4 = heapClassInst.heap32[r4];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine2];
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r8;
    heapClassInst.heap32[g0 + numDefine2] = r3;
    heapClassInst.heap32[g0 + numDefine3] = r2;
    functionTable[r4 >> numDefine2](i7);
    r0 = heapClassInst.heap32[r0 + 1];
    r1 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine6];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r3;
    functionTable[r1 >> numDefine2](i7);
    return;
  } else {
    r0 = twoEStr6187;
    r1 = twoEStr7188;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine130;
    assertNew(i7);
  }
}

function zzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4EN21MyNodeOverlapCallbackD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4EN21MyNodeOverlapCallbackD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4EN21MyNodeOverlapCallback11processNodeEii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg120;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + 1];
  r2 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = sp + numDefineNeg52;
  r5 = sp + numDefineNeg56;
  r6 = sp + numDefineNeg60;
  r7 = sp + numDefineNeg64;
  r8 = sp + numDefineNeg68;
  r9 = sp + numDefineNeg72;
  r10 = sp + numDefineNeg76;
  r11 = sp + numDefineNeg80;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  heapClassInst.heap32[g0 + numDefine3] = r6;
  heapClassInst.heap32[g0 + numDefine4] = r7;
  heapClassInst.heap32[g0 + numDefine5] = r8;
  heapClassInst.heap32[g0 + numDefine6] = r9;
  heapClassInst.heap32[g0 + numDefine7] = r10;
  heapClassInst.heap32[g0 + numDefine8] = r11;
  heapClassInst.heap32[g0 + numDefine9] = r3;
  functionTable[r2 >> numDefine2](i7);
  r1 = heapClassInst.heap32[fp + numDefineNeg20];
  r2 = (r1 + numDefineNeg2) | 0;
  if (uint(r2) < uint(numDefine2)) {
    r2 = heapClassInst.heap32[fp + numDefine2];
    r4 = heapClassInst.heap32[fp + numDefineNeg17];
    r5 = heapClassInst.heap32[fp + numDefineNeg18];
    r5 = (r5 * r2) | 0;
    r6 = heapClassInst.heap32[r0 + 1];
    r4 = (r4 + r5) | 0;
    r5 = numDefineNeg6;
    repeat3: while (true) {
      r7 = 0;
      r8 = r5 << 1;
      r7 = (r7 - r8) | 0;
      if (r1 !== numDefine3) {
        r8 = (r4 - r8) | 0;
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + -1];
      } else {
        r8 = (r4 - r5) | 0;
        r8 = heapClassInst.heapU16[(r8 + numDefineNeg2) >> 1];
      }
      r9 = heapClassInst.heap32[fp + numDefineNeg16];
      r10 = heapClassInst.heap32[fp + numDefineNeg13];
      r8 = (r9 * r8) | 0;
      r9 = heapClassInst.heap32[fp + numDefineNeg15];
      if (r9 !== 0) {
        r9 = (r10 + r8) | 0;
        r11 = r6 >> numDefine2;
        f0 = llvmReadDouble(r9 + numDefine16);
        f1 = llvmReadDouble(r9 + numDefine8);
        f2 = llvmReadDouble(r10 + r8);
        f0 = f0;
        f3 = heapClassInst.heapFloat[r11 + numDefine3];
        f1 = f1;
        f4 = heapClassInst.heapFloat[r11 + numDefine2];
        f2 = f2;
        f5 = heapClassInst.heapFloat[r11 + 1];
        f0 = f0 * f3;
        f1 = f1 * f4;
        f2 = f2 * f5;
      } else {
        r8 = (r10 + r8) | 0;
        r8 = r8 >> numDefine2;
        r10 = r6 >> numDefine2;
        f0 = heapClassInst.heapFloat[r8 + numDefine2];
        f1 = heapClassInst.heapFloat[r10 + numDefine3];
        f2 = heapClassInst.heapFloat[r8 + 1];
        f3 = heapClassInst.heapFloat[r10 + numDefine2];
        f4 = heapClassInst.heapFloat[r8];
        f5 = heapClassInst.heapFloat[r10 + 1];
        f0 = f0 * f1;
        f1 = f2 * f3;
        f2 = f4 * f5;
      }
      r8 = sp + numDefineNeg48;
      r9 = r7 << numDefine2;
      r10 = r7 << numDefine2;
      r9 = (r8 + r9) | 0;
      r11 = r7 << numDefine2;
      r10 = (r8 + r10) | 0;
      r9 = r9 >> numDefine2;
      r7 = r7 << numDefine2;
      r11 = (r8 + r11) | 0;
      r10 = r10 >> numDefine2;
      heapClassInst.heapFloat[r9 + numDefineNeg4] = f2;
      r7 = (r8 + r7) | 0;
      r9 = r11 >> numDefine2;
      heapClassInst.heapFloat[r10 + numDefineNeg3] = f1;
      r5 = (r5 + numDefine2) | 0;
      r7 = r7 >> numDefine2;
      heapClassInst.heapFloat[r9 + numDefineNeg2] = f0;
      heapClassInst.heap32[r7 + -1] = 0;
      if (!(r5 !== 0)) {
        break repeat3;
      }
    }
    r1 = heapClassInst.heap32[r0 + numDefine2];
    r4 = r1 >> numDefine2;
    r4 = heapClassInst.heap32[r4];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine2];
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r8;
    heapClassInst.heap32[g0 + numDefine2] = r3;
    heapClassInst.heap32[g0 + numDefine3] = r2;
    functionTable[r4 >> numDefine2](i7);
    r0 = heapClassInst.heap32[r0 + 1];
    r1 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine6];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r3;
    functionTable[r1 >> numDefine2](i7);
    return;
  } else {
    r0 = twoEStr6187;
    r1 = twoEStr7188;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine199;
    assertNew(i7);
  }
}

function zznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallbackD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallbackD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallback11processNodeEii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg72;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + 1];
  r3 = r2 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine4];
  r4 = heapClassInst.heap32[fp + 1];
  r5 = sp + numDefineNeg4;
  r6 = sp + numDefineNeg8;
  r7 = sp + numDefineNeg12;
  r8 = sp + numDefineNeg16;
  r9 = sp + numDefineNeg20;
  r10 = sp + numDefineNeg24;
  r11 = sp + numDefineNeg28;
  r12 = sp + numDefineNeg32;
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heap32[g0 + numDefine2] = r6;
  heapClassInst.heap32[g0 + numDefine3] = r7;
  heapClassInst.heap32[g0 + numDefine4] = r8;
  heapClassInst.heap32[g0 + numDefine5] = r9;
  heapClassInst.heap32[g0 + numDefine6] = r10;
  heapClassInst.heap32[g0 + numDefine7] = r11;
  heapClassInst.heap32[g0 + numDefine8] = r12;
  heapClassInst.heap32[g0 + numDefine9] = r4;
  functionTable[r3 >> numDefine2](i7);
  r2 = heapClassInst.heap32[fp + numDefineNeg8];
  r3 = (r2 + numDefineNeg2) | 0;
  if (uint(r3) < uint(numDefine2)) {
    r3 = heapClassInst.heap32[fp + numDefine2];
    r5 = heapClassInst.heap32[fp + numDefineNeg5];
    r6 = heapClassInst.heap32[fp + numDefineNeg6];
    r6 = (r6 * r3) | 0;
    r5 = (r6 + r5) | 0;
    r6 = heapClassInst.heap32[r1 + 1];
    r5 = (r5 + numDefine8) | 0;
    r7 = 0;
    r8 = r7;
    repeat3: while (true) {
      r9 = r8 << 1;
      r10 = (r7 - r9) | 0;
      if (r2 !== numDefine3) {
        r9 = (r5 - r9) | 0;
        r9 = r9 >> numDefine2;
        r9 = heapClassInst.heap32[r9];
      } else {
        r9 = (r5 - r8) | 0;
        r9 = heapClassInst.heapU16[(r9 + numDefineNeg4) >> 1];
      }
      r11 = heapClassInst.heap32[fp + numDefineNeg4];
      r12 = heapClassInst.heap32[fp + -1];
      r9 = (r11 * r9) | 0;
      r11 = heapClassInst.heap32[fp + numDefineNeg3];
      if (r11 !== 0) {
        r11 = (r12 + r9) | 0;
        r13 = r6 >> numDefine2;
        f0 = llvmReadDouble(r11 + numDefine16);
        f1 = llvmReadDouble(r11 + numDefine8);
        f2 = llvmReadDouble(r12 + r9);
        f0 = f0;
        f3 = heapClassInst.heapFloat[r13 + numDefine3];
        f1 = f1;
        f4 = heapClassInst.heapFloat[r13 + numDefine2];
        f2 = f2;
        f5 = heapClassInst.heapFloat[r13 + 1];
        f0 = f0 * f3;
        f1 = f1 * f4;
        f2 = f2 * f5;
      } else {
        r9 = (r12 + r9) | 0;
        r9 = r9 >> numDefine2;
        r12 = r6 >> numDefine2;
        f0 = heapClassInst.heapFloat[r9 + numDefine2];
        f1 = heapClassInst.heapFloat[r12 + numDefine3];
        f2 = heapClassInst.heapFloat[r9 + 1];
        f3 = heapClassInst.heapFloat[r12 + numDefine2];
        f4 = heapClassInst.heapFloat[r9];
        f5 = heapClassInst.heapFloat[r12 + 1];
        f0 = f0 * f1;
        f1 = f2 * f3;
        f2 = f4 * f5;
      }
      r9 = r10 << numDefine2;
      r11 = r10 << numDefine2;
      r9 = (r0 + r9) | 0;
      r12 = r10 << numDefine2;
      r11 = (r0 + r11) | 0;
      r9 = r9 >> numDefine2;
      r10 = r10 << numDefine2;
      r12 = (r0 + r12) | 0;
      r11 = r11 >> numDefine2;
      heapClassInst.heapFloat[r9 + numDefine11] = f2;
      r9 = (r0 + r10) | 0;
      r10 = r12 >> numDefine2;
      heapClassInst.heapFloat[r11 + numDefine12] = f1;
      r8 = (r8 + numDefine2) | 0;
      r9 = r9 >> numDefine2;
      heapClassInst.heapFloat[r10 + numDefine13] = f0;
      heapClassInst.heap32[r9 + numDefine14] = 0;
      if (!(r8 !== numDefine6)) {
        break repeat3;
      }
    }
    r2 = heapClassInst.heap32[r1 + numDefine2];
    r5 = r2 >> numDefine2;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine2];
    r0 = (r0 + numDefine12) | 0;
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    heapClassInst.heap32[g0 + numDefine3] = r3;
    functionTable[r5 >> numDefine2](i7);
    r0 = heapClassInst.heap32[r1 + 1];
    r1 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine6];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r4;
    functionTable[r1 >> numDefine2](i7);
    return;
  } else {
    r0 = twoEStr6187;
    r1 = twoEStr7188;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine280;
    assertNew(i7);
  }
}

function znk22btBvhTriangleMeshShape18serializeSingleBvhEP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine13];
  if (!(r1 === 0)) {
    r2 = heapClassInst.heap32[fp + 1];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine3];
    heapClassInst.heap32[g0] = r1;
    functionTable[r3 >> numDefine2](i7);
    r3 = r2 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine4];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
    heapClassInst.heap32[g0 + numDefine2] = 1;
    functionTable[r4 >> numDefine2](i7);
    r1 = commonVariable.rg0;
    r4 = heapClassInst.heap32[r0 + numDefine13];
    r5 = r4 >> numDefine2;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r6 = r1 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine4];
    r6 = heapClassInst.heap32[r6 + numDefine2];
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r6;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    functionTable[r5 >> numDefine2](i7);
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine5];
    r0 = heapClassInst.heap32[r0 + numDefine13];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
    heapClassInst.heap32[g0 + numDefine3] = numDefine12625;
    heapClassInst.heap32[g0 + numDefine4] = r0;
    functionTable[r3 >> numDefine2](i7);
  }
  return;
}

function znk22btBvhTriangleMeshShape30serializeSingleTriangleInfoMapEP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine14];
  if (!(r1 === 0)) {
    r2 = heapClassInst.heap32[fp + 1];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine2];
    heapClassInst.heap32[g0] = r1;
    functionTable[r3 >> numDefine2](i7);
    r3 = r2 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine4];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
    heapClassInst.heap32[g0 + numDefine2] = 1;
    functionTable[r4 >> numDefine2](i7);
    r1 = commonVariable.rg0;
    r4 = heapClassInst.heap32[r0 + numDefine14];
    r5 = r4 >> numDefine2;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r6 = r1 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine3];
    r6 = heapClassInst.heap32[r6 + numDefine2];
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r6;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    functionTable[r5 >> numDefine2](i7);
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine5];
    r0 = heapClassInst.heap32[r0 + numDefine14];
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
    heapClassInst.heap32[g0 + numDefine3] = numDefine56916;
    heapClassInst.heap32[g0 + numDefine4] = r0;
    functionTable[r3 >> numDefine2](i7);
  }
  return;
}

function znk19btTriangleMeshShape37localGetSupportingVertexWithoutMarginERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr10;
  r1 = twoEStr5186;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = numDefine43;
  assertNew(i7);
}

function znk22btBvhTriangleMeshShape9serializeEPvP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine10];
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r4 = heapClassInst.heap32[r1];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine7];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  r5 = heapClassInst.heap32[fp + 1];
  functionTable[r4 >> numDefine2](i7);
  r4 = commonVariable.rg0;
  r6 = r5 >> numDefine2;
  heapClassInst.heap32[r6] = r4;
  if (!(r4 === 0)) {
    r4 = heapClassInst.heap32[r1];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine12];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    functionTable[r4 >> numDefine2](i7);
  }
  r2 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + 1];
  heapClassInst.heap32[r6 + 1] = r3;
  r3 = heapClassInst.heap32[r2 + numDefine12];
  r4 = r3 >> numDefine2;
  r4 = heapClassInst.heap32[r4];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine14];
  r5 = (r5 + numDefine12) | 0;
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heap32[g0 + numDefine2] = r0;
  functionTable[r4 >> numDefine2](i7);
  heapClassInst.heap32[r6 + numDefine13] = heapClassInst.heap32[r2 + numDefine3];
  r3 = heapClassInst.heap32[r2 + numDefine13];
  if (r3 === 0) {
    label = numDefine4;
  } else {
    r3 = heapClassInst.heap32[r1];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine13];
    heapClassInst.heap32[g0] = r0;
    functionTable[r3 >> numDefine2](i7);
    r3 = commonVariable.rg0 & 1;
    if (r3 === 0) {
      r3 = heapClassInst.heap32[r1];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine6];
      r4 = heapClassInst.heap32[r2 + numDefine13];
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r4;
      functionTable[r3 >> numDefine2](i7);
      r3 = commonVariable.rg0;
      if (r3 === 0) {
        r3 = heapClassInst.heap32[r1];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine7];
        r4 = heapClassInst.heap32[r2 + numDefine13];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        functionTable[r3 >> numDefine2](i7);
        heapClassInst.heap32[r6 + numDefine10] = commonVariable.rg0;
        heapClassInst.heap32[r6 + numDefine11] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine13];
        r4 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine3];
        heapClassInst.heap32[g0] = r3;
        functionTable[r4 >> numDefine2](i7);
        r4 = heapClassInst.heap32[r1];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        functionTable[r4 >> numDefine2](i7);
        r3 = commonVariable.rg0;
        r4 = heapClassInst.heap32[r2 + numDefine13];
        r5 = r4 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        r5 = r5 >> numDefine2;
        r7 = r3 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine4];
        r7 = heapClassInst.heap32[r7 + numDefine2];
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = r7;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        functionTable[r5 >> numDefine2](i7);
        r5 = heapClassInst.heap32[r1];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine5];
        r7 = heapClassInst.heap32[r2 + numDefine13];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine3] = numDefine12625;
        heapClassInst.heap32[g0 + numDefine4] = r7;
        functionTable[r5 >> numDefine2](i7);
        label = numDefine8;
      } else {
        heapClassInst.heap32[r6 + numDefine10] = r3;
        heapClassInst.heap32[r6 + numDefine11] = 0;
        label = numDefine8;
      }
    } else {
      label = numDefine4;
    }
  }
  if (label === numDefine4) {
    heapClassInst.heap32[r6 + numDefine10] = 0;
    heapClassInst.heap32[r6 + numDefine11] = 0;
  }
  r3 = heapClassInst.heap32[r2 + numDefine14];
  if (r3 === 0) {
    label = numDefine10;
  } else {
    r3 = heapClassInst.heap32[r1];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine13];
    heapClassInst.heap32[g0] = r0;
    functionTable[r3 >> numDefine2](i7);
    r3 = commonVariable.rg0 & numDefine2;
    if (r3 === 0) {
      r3 = heapClassInst.heap32[r1];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine6];
      r4 = heapClassInst.heap32[r2 + numDefine14];
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r4;
      functionTable[r3 >> numDefine2](i7);
      r3 = commonVariable.rg0;
      if (r3 === 0) {
        r3 = heapClassInst.heap32[r1];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine7];
        r4 = heapClassInst.heap32[r2 + numDefine14];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        functionTable[r3 >> numDefine2](i7);
        heapClassInst.heap32[r6 + numDefine12] = commonVariable.rg0;
        r3 = heapClassInst.heap32[r2 + numDefine14];
        r4 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine2];
        heapClassInst.heap32[g0] = r3;
        functionTable[r4 >> numDefine2](i7);
        r4 = heapClassInst.heap32[r1];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        functionTable[r4 >> numDefine2](i7);
        r3 = commonVariable.rg0;
        r4 = heapClassInst.heap32[r2 + numDefine14];
        r5 = r4 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        r5 = r5 >> numDefine2;
        r6 = r3 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine3];
        r6 = heapClassInst.heap32[r6 + numDefine2];
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        functionTable[r5 >> numDefine2](i7);
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine5];
        r2 = heapClassInst.heap32[r2 + numDefine14];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine3] = numDefine56916;
        heapClassInst.heap32[g0 + numDefine4] = r2;
        functionTable[r1 >> numDefine2](i7);
        label = numDefine11;
      } else {
        heapClassInst.heap32[r6 + numDefine12] = r3;
        label = numDefine11;
      }
    } else {
      label = numDefine10;
    }
  }
  if (label === numDefine10) {
    heapClassInst.heap32[r6 + numDefine12] = 0;
  }
  r0 = twoEStr8189;
  commonVariable.rg0 = r0;
  return;
}

function zn22btBvhTriangleMeshShape17buildOptimizedBvhEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg72;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine61];
  if (!(r1 === 0)) {
    r1 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r1 + numDefine13];
    r3 = r2 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    heapClassInst.heap32[g0] = r2;
    functionTable[r3 >> numDefine2](i7);
    r1 = heapClassInst.heap32[r1 + numDefine13];
    if (!(r1 === 0)) {
      r2 = gNumAlignedFree;
      r2 = r2 >> numDefine2;
      r3 = heapClassInst.heap32[r2];
      r3 = (r3 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r2] = r3;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r1 = gNumAlignedAllocs;
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = (r2 + 1) | 0;
  heapClassInst.heap32[r1] = r2;
  heapClassInst.heap32[g0] = numDefine191;
  mallocNew(i7);
  r2 = commonVariable.rg0;
  if (r2 !== 0) {
    r3 = 0;
    r4 = (r2 + numDefine4) | 0;
    r3 = (r3 - r4) | 0;
    r3 = r3 & numDefine15;
    r3 = (r2 + r3) | 0;
    r4 = (r3 + numDefine4) | 0;
    r3 = r3 >> numDefine2;
    heapClassInst.heap32[r3] = r2;
    r2 = r4;
  }
  r3 = r2 >> numDefine2;
  r4 = 1;
  heapClassInst.heap32[r3 + numDefine13] = numDefine277;
  heapClassInst.heap8[r2 + numDefine80] = r4;
  heapClassInst.heap32[r3 + numDefine19] = 0;
  heapClassInst.heap32[r3 + numDefine17] = 0;
  heapClassInst.heap32[r3 + numDefine18] = 0;
  heapClassInst.heap8[r2 + numDefine100] = r4;
  heapClassInst.heap32[r3 + numDefine24] = 0;
  heapClassInst.heap32[r3 + numDefine22] = 0;
  heapClassInst.heap32[r3 + numDefine23] = 0;
  heapClassInst.heap8[r2 + numDefine120] = r4;
  heapClassInst.heap32[r3 + numDefine29] = 0;
  heapClassInst.heap32[r3 + numDefine27] = 0;
  heapClassInst.heap32[r3 + numDefine28] = 0;
  heapClassInst.heap8[r2 + numDefine140] = r4;
  heapClassInst.heap32[r3 + numDefine34] = 0;
  heapClassInst.heap32[r3 + numDefine32] = 0;
  heapClassInst.heap32[r3 + numDefine33] = 0;
  heapClassInst.heap32[r3 + numDefine36] = 0;
  heapClassInst.heap8[r2 + numDefine164] = r4;
  heapClassInst.heap32[r3 + numDefine40] = 0;
  heapClassInst.heap32[r3 + numDefine38] = 0;
  heapClassInst.heap32[r3 + numDefine39] = 0;
  heapClassInst.heap32[r3 + numDefine42] = 0;
  heapClassInst.heap32[r3 + 1] = numDefineNeg88609;
  heapClassInst.heap32[r3 + numDefine2] = numDefineNeg88609;
  heapClassInst.heap32[r3 + numDefine3] = numDefineNeg88609;
  heapClassInst.heap32[r3 + numDefine4] = 0;
  heapClassInst.heap32[r3 + numDefine5] = numDefine95039;
  heapClassInst.heap32[r3 + numDefine6] = numDefine95039;
  r5 = ztv14btOptimizedBvh;
  heapClassInst.heap32[r3 + numDefine7] = numDefine95039;
  r5 = (r5 + numDefine8) | 0;
  heapClassInst.heap32[r3 + numDefine8] = 0;
  r6 = r0 >> numDefine2;
  heapClassInst.heap32[r3] = r5;
  heapClassInst.heap32[r6 + numDefine13] = r2;
  r5 = heapClassInst.heap32[r6 + numDefine12];
  r7 = heapClassInst.heapU8[r0 + numDefine60];
  heapClassInst.heap8[r2 + numDefine60] = r7;
  if (r7 === 0) {
    r6 = ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback;
    r7 = sp + numDefineNeg24;
    r6 = (r6 + numDefine8) | 0;
    r8 = r7 >> numDefine2;
    r9 = (r2 + numDefine64) | 0;
    heapClassInst.heap32[fp + numDefineNeg6] = r6;
    r6 = sp + numDefineNeg40;
    heapClassInst.heap32[r8 + 1] = r9;
    r8 = r6 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg10] = numDefineNeg39253;
    heapClassInst.heap32[r8 + 1] = numDefineNeg39253;
    heapClassInst.heap32[r8 + numDefine2] = numDefineNeg39253;
    r9 = sp + numDefineNeg56;
    heapClassInst.heap32[r8 + numDefine3] = 0;
    r8 = r9 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg14] = numDefine44395;
    heapClassInst.heap32[r8 + 1] = numDefine44395;
    heapClassInst.heap32[r8 + numDefine2] = numDefine44395;
    r10 = r5 >> numDefine2;
    heapClassInst.heap32[r8 + numDefine3] = 0;
    r8 = heapClassInst.heap32[r10];
    r8 = r8 >> numDefine2;
    r8 = heapClassInst.heap32[r8 + numDefine2];
    heapClassInst.heap32[g0] = r5;
    heapClassInst.heap32[g0 + 1] = r7;
    heapClassInst.heap32[g0 + numDefine2] = r6;
    heapClassInst.heap32[g0 + numDefine3] = r9;
    functionTable[r8 >> numDefine2](i7);
    r5 = heapClassInst.heap32[r3 + numDefine17];
    r6 = heapClassInst.heap32[r3 + numDefine22];
    r7 = r5 << 1;
    if (!(r6 >= r7)) {
      r8 = heapClassInst.heap32[r3 + numDefine23];
      if (!(r8 >= r7)) {
        if (r7 !== 0) {
          r8 = heapClassInst.heap32[r1];
          r8 = (r8 + 1) | 0;
          r9 = r5 << numDefine7;
          heapClassInst.heap32[r1] = r8;
          r8 = r9 | numDefine19;
          heapClassInst.heap32[g0] = r8;
          mallocNew(i7);
          r8 = commonVariable.rg0;
          if (r8 !== 0) {
            r9 = 0;
            r10 = (r8 + numDefine4) | 0;
            r9 = (r9 - r10) | 0;
            r9 = r9 & numDefine15;
            r9 = (r8 + r9) | 0;
            r10 = (r9 + numDefine4) | 0;
            r9 = r9 >> numDefine2;
            heapClassInst.heap32[r9] = r8;
            r8 = r10;
          }
        } else {
          r8 = 0;
        }
        if (!(r6 < 1)) {
          r9 = 0;
          repeat20: while (true) {
            r10 = heapClassInst.heap32[r3 + numDefine24];
            r11 = (r8 + r9) | 0;
            r10 = (r10 + r9) | 0;
            heapClassInst.heap32[g0] = r11;
            heapClassInst.heap32[g0 + 1] = r10;
            heapClassInst.heap32[g0 + numDefine2] = numDefine64;
            r6 = (r6 + -1) | 0;
            r9 = (r9 + numDefine64) | 0;
            memcpy(i7);
            if (!(r6 !== 0)) {
              break repeat20;
            }
          }
        }
        r6 = heapClassInst.heap32[r3 + numDefine24];
        if (!(r6 === 0)) {
          r9 = heapClassInst.heapU8[r2 + numDefine100];
          if (!(r9 === 0)) {
            r9 = gNumAlignedFree;
            r9 = r9 >> numDefine2;
            r10 = heapClassInst.heap32[r9];
            r10 = (r10 + 1) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r9] = r10;
            r6 = heapClassInst.heap32[r6 + -1];
            heapClassInst.heap32[g0] = r6;
            free(i7);
          }
          heapClassInst.heap32[r3 + numDefine24] = 0;
        }
        r6 = 1;
        heapClassInst.heap8[r2 + numDefine100] = r6;
        heapClassInst.heap32[r3 + numDefine24] = r8;
        heapClassInst.heap32[r3 + numDefine23] = r7;
      }
    }
    r6 = ztv31btInternalTriangleIndexCallback;
    r6 = (r6 + numDefine8) | 0;
    heapClassInst.heap32[r3 + numDefine22] = r7;
    heapClassInst.heap32[fp + numDefineNeg6] = r6;
  } else {
    r7 = (r2 + numDefine4) | 0;
    r8 = (r2 + numDefine20) | 0;
    f0 = -1;
    f1 = heapClassInst.heapFloat[r6 + numDefine6];
    f2 = heapClassInst.heapFloat[r6 + numDefine5];
    f3 = heapClassInst.heapFloat[r6 + numDefine4];
    f3 = f3 + f0;
    f2 = f2 + f0;
    heapClassInst.heapFloat[r3 + 1] = f3;
    f0 = f1 + f0;
    heapClassInst.heapFloat[r3 + numDefine2] = f2;
    heapClassInst.heapFloat[r3 + numDefine3] = f0;
    heapClassInst.heap32[r3 + numDefine4] = 0;
    f1 = 1;
    f4 = heapClassInst.heapFloat[r6 + numDefine10];
    f5 = heapClassInst.heapFloat[r6 + numDefine9];
    f6 = heapClassInst.heapFloat[r6 + numDefine8];
    f6 = f6 + f1;
    f5 = f5 + f1;
    heapClassInst.heapFloat[r3 + numDefine5] = f6;
    f1 = f4 + f1;
    heapClassInst.heapFloat[r3 + numDefine6] = f5;
    heapClassInst.heapFloat[r3 + numDefine7] = f1;
    f4 = numDefine65533;
    f3 = f6 - f3;
    f2 = f5 - f2;
    f3 = f4 / f3;
    heapClassInst.heap32[r3 + numDefine8] = 0;
    f0 = f1 - f0;
    f1 = f4 / f2;
    heapClassInst.heapFloat[r3 + numDefine9] = f3;
    f0 = f4 / f0;
    heapClassInst.heapFloat[r3 + numDefine10] = f1;
    heapClassInst.heapFloat[r3 + numDefine11] = f0;
    r6 = ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback;
    heapClassInst.heap32[r3 + numDefine12] = 0;
    r9 = sp + numDefineNeg16;
    r6 = (r6 + numDefine8) | 0;
    heapClassInst.heap8[r2 + numDefine60] = r4;
    r10 = r9 >> numDefine2;
    r11 = (r2 + numDefine104) | 0;
    heapClassInst.heap32[fp + numDefineNeg4] = r6;
    heapClassInst.heap32[r10 + 1] = r11;
    r6 = r5 >> numDefine2;
    heapClassInst.heap32[r10 + numDefine2] = r2;
    r6 = heapClassInst.heap32[r6];
    r6 = r6 >> numDefine2;
    r6 = heapClassInst.heap32[r6 + numDefine2];
    heapClassInst.heap32[g0] = r5;
    heapClassInst.heap32[g0 + 1] = r9;
    heapClassInst.heap32[g0 + numDefine2] = r7;
    heapClassInst.heap32[g0 + numDefine3] = r8;
    functionTable[r6 >> numDefine2](i7);
    r5 = heapClassInst.heap32[r3 + numDefine27];
    r6 = heapClassInst.heap32[r3 + numDefine32];
    r7 = r5 << 1;
    repeat31: do {
      if (!(r6 >= r7)) {
        r8 = (r2 + numDefine124) | 0;
        heapClassInst.heap32[g0] = r8;
        heapClassInst.heap32[g0 + 1] = r7;
        r8 = (r7 - r6) | 0;
        r6 = r6 << numDefine4;
        zn20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi(i7);
        while (true) {
          r9 = heapClassInst.heap32[r3 + numDefine34];
          r9 = (r9 + r6) | 0;
          r9 = r9 >> numDefine2;
          r8 = (r8 + -1) | 0;
          r6 = (r6 + numDefine16) | 0;
          heapClassInst.heap32[r9] = 0;
          heapClassInst.heap32[r9 + 1] = 0;
          heapClassInst.heap32[r9 + numDefine2] = 0;
          heapClassInst.heap32[r9 + numDefine3] = 0;
          if (!(r8 !== 0)) {
            break repeat31;
          }
        }
      }
    } while (false);
    r6 = ztv31btInternalTriangleIndexCallback;
    r6 = (r6 + numDefine8) | 0;
    heapClassInst.heap32[r3 + numDefine32] = r7;
    heapClassInst.heap32[fp + numDefineNeg4] = r6;
  }
  heapClassInst.heap32[r3 + numDefine14] = 0;
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = 0;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  zn14btQuantizedBvh9buildTreeEii(i7);
  r5 = heapClassInst.heapU8[r2 + numDefine60];
  if (!(r5 === 0)) {
    r5 = heapClassInst.heap32[r3 + numDefine38];
    if (!(r5 !== 0)) {
      r6 = heapClassInst.heap32[r3 + numDefine39];
      if (r6 !== r5) {
        label = numDefine29;
      } else {
        if (r6 < 1) {
          r6 = heapClassInst.heap32[r1];
          r6 = (r6 + 1) | 0;
          heapClassInst.heap32[r1] = r6;
          heapClassInst.heap32[g0] = numDefine51;
          mallocNew(i7);
          r1 = commonVariable.rg0;
          if (r1 !== 0) {
            r6 = 0;
            r7 = (r1 + numDefine4) | 0;
            r6 = (r6 - r7) | 0;
            r6 = r6 & numDefine15;
            r6 = (r1 + r6) | 0;
            r7 = (r6 + numDefine4) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6] = r1;
            r1 = r7;
          }
          r6 = heapClassInst.heap32[r3 + numDefine40];
          if (!(r6 === 0)) {
            r7 = heapClassInst.heapU8[r2 + numDefine164];
            if (!(r7 === 0)) {
              r7 = gNumAlignedFree;
              r7 = r7 >> numDefine2;
              r8 = heapClassInst.heap32[r7];
              r8 = (r8 + 1) | 0;
              r6 = r6 >> numDefine2;
              heapClassInst.heap32[r7] = r8;
              r6 = heapClassInst.heap32[r6 + -1];
              heapClassInst.heap32[g0] = r6;
              free(i7);
            }
            heapClassInst.heap32[r3 + numDefine40] = 0;
          }
          r6 = 1;
          heapClassInst.heap8[r2 + numDefine164] = r6;
          heapClassInst.heap32[r3 + numDefine40] = r1;
          heapClassInst.heap32[r3 + numDefine39] = 1;
          r6 = heapClassInst.heap32[r3 + numDefine38];
          r6 = (r6 + 1) | 0;
          label = numDefine37;
        } else {
          label = numDefine29;
        }
      }
      if (label === numDefine29) {
        r1 = heapClassInst.heap32[r3 + numDefine40];
        r6 = r4;
      }
      heapClassInst.heap32[r3 + numDefine38] = r6;
      r6 = heapClassInst.heap32[r3 + numDefine34];
      r7 = heapClassInst.heapU16[r6 >> 1];
      r5 = r5 << numDefine5;
      heapClassInst.heap16[(r1 + r5) >> 1] = r7;
      r1 = (r1 + r5) | 0;
      r5 = heapClassInst.heapU16[(r6 + numDefine2) >> 1];
      heapClassInst.heap16[(r1 + numDefine2) >> 1] = r5;
      r5 = heapClassInst.heapU16[(r6 + numDefine4) >> 1];
      heapClassInst.heap16[(r1 + numDefine4) >> 1] = r5;
      r5 = heapClassInst.heapU16[(r6 + numDefine6) >> 1];
      heapClassInst.heap16[(r1 + numDefine6) >> 1] = r5;
      r5 = heapClassInst.heapU16[(r6 + numDefine8) >> 1];
      heapClassInst.heap16[(r1 + numDefine8) >> 1] = r5;
      r5 = heapClassInst.heapU16[(r6 + numDefine10) >> 1];
      r6 = r1 >> numDefine2;
      heapClassInst.heap16[(r1 + numDefine10) >> 1] = r5;
      heapClassInst.heap32[r6 + numDefine3] = 0;
      r1 = heapClassInst.heap32[r3 + numDefine34];
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine3];
      r5 = 0;
      r5 = (r5 - r1) | 0;
      r1 = r1 < 0 ? r5 : r4;
      heapClassInst.heap32[r6 + numDefine4] = r1;
    }
  }
  r1 = heapClassInst.heap32[r3 + numDefine38];
  heapClassInst.heap32[r3 + numDefine42] = r1;
  r1 = heapClassInst.heap32[r3 + numDefine29];
  if (!(r1 === 0)) {
    r4 = heapClassInst.heapU8[r2 + numDefine120];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r3 + numDefine29] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r2 + numDefine120] = r1;
  heapClassInst.heap32[r3 + numDefine29] = 0;
  heapClassInst.heap32[r3 + numDefine27] = 0;
  heapClassInst.heap32[r3 + numDefine28] = 0;
  r4 = heapClassInst.heap32[r3 + numDefine19];
  if (!(r4 === 0)) {
    r5 = heapClassInst.heapU8[r2 + numDefine80];
    if (!(r5 === 0)) {
      r5 = gNumAlignedFree;
      r5 = r5 >> numDefine2;
      r6 = heapClassInst.heap32[r5];
      r6 = (r6 + 1) | 0;
      r4 = r4 >> numDefine2;
      heapClassInst.heap32[r5] = r6;
      r4 = heapClassInst.heap32[r4 + -1];
      heapClassInst.heap32[g0] = r4;
      free(i7);
    }
    heapClassInst.heap32[r3 + numDefine19] = 0;
  }
  heapClassInst.heap8[r2 + numDefine80] = r1;
  heapClassInst.heap32[r3 + numDefine19] = 0;
  heapClassInst.heap32[r3 + numDefine17] = 0;
  heapClassInst.heap32[r3 + numDefine18] = 0;
  heapClassInst.heap8[r0 + numDefine61] = r1;
  return;
}

function zn22btBvhTriangleMeshShape15setLocalScalingERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine7];
  heapClassInst.heap32[g0] = r0;
  r3 = heapClassInst.heap32[fp + 1];
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0 >> numDefine2;
  r3 = r3 >> numDefine2;
  f0 = heapClassInst.heapFloat[r3];
  f1 = heapClassInst.heapFloat[r2];
  f2 = heapClassInst.heapFloat[r2 + 1];
  f3 = heapClassInst.heapFloat[r3 + 1];
  f1 = f1 - f0;
  f2 = f2 - f3;
  f3 = heapClassInst.heapFloat[r2 + numDefine2];
  f4 = heapClassInst.heapFloat[r3 + numDefine2];
  f3 = f3 - f4;
  f1 = f1 * f1;
  f2 = f2 * f2;
  f1 = f1 + f2;
  f2 = f3 * f3;
  f1 = f1 + f2;
  f2 = numDefineFloat1257;
  if (!(f1 <= f2)) {
    r1 = heapClassInst.heap32[r1 + numDefine12];
    r1 = r1 >> numDefine2;
    heapClassInst.heapFloat[r1 + 1] = f0;
    heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r3 + 1];
    heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r3 + numDefine3];
    heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r3 + numDefine3];
    heapClassInst.heap32[g0] = r0;
    zn19btTriangleMeshShape15recalcLocalAabbEv(i7);
    heapClassInst.heap32[g0] = r0;
    zn22btBvhTriangleMeshShape17buildOptimizedBvhEv(i7);
  }
  return;
}

function znk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg80;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = ztvznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback;
  r2 = sp + numDefineNeg64;
  r3 = heapClassInst.heap32[r0 + numDefine12];
  r1 = (r1 + numDefine8) | 0;
  r4 = r2 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg16] = r1;
  r1 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[r4 + 1] = r3;
  heapClassInst.heap32[r4 + numDefine2] = r1;
  r0 = heapClassInst.heap32[r0 + numDefine13];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r1;
  heapClassInst.heap32[g0 + numDefine3] = r3;
  znk14btQuantizedBvh26reportAabbOverlappingNodexEP21btNodeOverlapCallbackRK9btVector3S4(i7);
  return;
}

function zn22btBvhTriangleMeshShapeD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv22btBvhTriangleMeshShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine61];
  if (r1 === 0) {
    label = numDefine3;
  } else {
    r1 = heapClassInst.heap32[r2 + numDefine13];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    heapClassInst.heap32[g0] = r1;
    functionTable[r3 >> numDefine2](i7);
    r1 = heapClassInst.heap32[r2 + numDefine13];
    if (r1 === 0) {
      label = numDefine3;
    } else {
      r0 = gNumAlignedFree;
      r0 = r0 >> numDefine2;
      r3 = heapClassInst.heap32[r0];
      r3 = (r3 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r0] = r3;
      r0 = heapClassInst.heap32[r1 + -1];
      r1 = ztv14btConcaveShape;
      heapClassInst.heap32[g0] = r0;
      r0 = (r1 + numDefine8) | 0;
      free(i7);
      heapClassInst.heap32[r2] = r0;
      label = numDefine4;
    }
  }
  if (label === numDefine3) {
    r1 = ztv14btConcaveShape;
    r1 = (r1 + numDefine8) | 0;
    heapClassInst.heap32[r2] = r1;
    if (r0 === 0) {
      label = numDefine5;
    } else {
      label = numDefine4;
    }
  }
  if (label === numDefine4) {
    r0 = gNumAlignedFree;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0];
    r1 = (r1 + 1) | 0;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r2 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}

function zn22btBvhTriangleMeshShapeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv22btBvhTriangleMeshShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r0 = heapClassInst.heapU8[r0 + numDefine61];
  if (!(r0 === 0)) {
    r0 = heapClassInst.heap32[r2 + numDefine13];
    r1 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1];
    heapClassInst.heap32[g0] = r0;
    functionTable[r1 >> numDefine2](i7);
    r0 = heapClassInst.heap32[r2 + numDefine13];
    if (!(r0 === 0)) {
      r1 = gNumAlignedFree;
      r1 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r1];
      r3 = (r3 + 1) | 0;
      r0 = r0 >> numDefine2;
      heapClassInst.heap32[r1] = r3;
      r0 = heapClassInst.heap32[r0 + -1];
      heapClassInst.heap32[g0] = r0;
      free(i7);
    }
  }
  r0 = ztv14btConcaveShape;
  r0 = (r0 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r0;
  return;
}

function znk21btConvexInternalShape36getNumPreferredPenetrationDirectionsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn14btCapsuleShape9setMarginEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f1 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f2 = commonVariable.fg0;
  f3 = heapClassInst.heapFloat[r1 + numDefine9];
  f4 = heapClassInst.heapFloat[r1 + numDefine8];
  f5 = heapClassInst.heapFloat[r1 + numDefine7];
  heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f6 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f7 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  f2 = f5 + f2;
  functionTable[r2 >> numDefine2](i7);
  f1 = f4 + f1;
  f2 = f2 - commonVariable.fg0;
  f0 = f3 + f0;
  f1 = f1 - f7;
  heapClassInst.heapFloat[r1 + numDefine7] = f2;
  f0 = f0 - f6;
  heapClassInst.heapFloat[r1 + numDefine8] = f1;
  heapClassInst.heapFloat[r1 + numDefine9] = f0;
  heapClassInst.heap32[r1 + numDefine10] = 0;
  return;
}

function znk14btCapsuleShape7getNameEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr194;
  commonVariable.rg0 = r0;
  return;
}

function znk14btCapsuleShape7getAabbERK11btTransformR9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine13];
  r3 = (r2 + numDefine2) | 0;
  r3 = r3 % numDefine3 | 0;
  r4 = (r0 + numDefine28) | 0;
  r3 = r3 << numDefine2;
  r3 = (r4 + r3) | 0;
  r3 = r3 >> numDefine2;
  f0 = heapClassInst.heapFloat[r3];
  r3 = sp + numDefineNeg16;
  r5 = r3 >> numDefine2;
  heapClassInst.heapFloat[fp + numDefineNeg4] = f0;
  r2 = r2 << numDefine2;
  heapClassInst.heapFloat[r5 + 1] = f0;
  r4 = (r4 + r2) | 0;
  heapClassInst.heapFloat[r5 + numDefine2] = f0;
  r4 = r4 >> numDefine2;
  heapClassInst.heap32[r5 + numDefine3] = 0;
  r2 = (r3 + r2) | 0;
  f1 = heapClassInst.heapFloat[r4];
  r2 = r2 >> numDefine2;
  f0 = f0 + f1;
  heapClassInst.heapFloat[r2] = f0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f1 = commonVariable.fg0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  f3 = heapClassInst.heapFloat[fp + numDefineNeg4];
  f2 = f3 + commonVariable.fg0;
  heapClassInst.heapFloat[fp + numDefineNeg4] = f2;
  f3 = heapClassInst.heapFloat[r5 + 1];
  f1 = f3 + f1;
  heapClassInst.heapFloat[r5 + 1] = f1;
  f3 = heapClassInst.heapFloat[r5 + numDefine2];
  r0 = heapClassInst.heap32[fp + 1];
  f0 = f3 + f0;
  r0 = r0 >> numDefine2;
  heapClassInst.heapFloat[r5 + numDefine2] = f0;
  f3 = heapClassInst.heapFloat[r0 + numDefine10];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r2 = heapClassInst.heap32[fp + numDefine3];
  f4 = 0;
  if (f3 < f4) {
    f3 = -f3;
  }
  f5 = heapClassInst.heapFloat[r0 + numDefine9];
  if (f5 < f4) {
    f5 = -f5;
  }
  f6 = heapClassInst.heapFloat[r0 + numDefine8];
  if (f6 < f4) {
    f6 = -f6;
  }
  f7 = heapClassInst.heapFloat[r0 + numDefine6];
  if (f7 < f4) {
    f7 = -f7;
  }
  f8 = heapClassInst.heapFloat[r0 + numDefine5];
  if (f8 < f4) {
    f8 = -f8;
  }
  f9 = heapClassInst.heapFloat[r0 + numDefine4];
  if (f9 < f4) {
    f9 = -f9;
  }
  f10 = heapClassInst.heapFloat[r0 + numDefine2];
  if (f10 < f4) {
    f10 = -f10;
  }
  f11 = heapClassInst.heapFloat[r0 + 1];
  if (f11 < f4) {
    f11 = -f11;
  }
  f12 = heapClassInst.heapFloat[r0];
  if (f12 < f4) {
    f12 = -f12;
  }
  f4 = f12 * f2;
  f11 = f11 * f1;
  f9 = f9 * f2;
  f8 = f8 * f1;
  f4 = f4 + f11;
  f10 = f10 * f0;
  f2 = f6 * f2;
  f1 = f5 * f1;
  f5 = f9 + f8;
  f6 = f7 * f0;
  f4 = f4 + f10;
  f7 = heapClassInst.heapFloat[r0 + numDefine12];
  f8 = heapClassInst.heapFloat[r0 + numDefine13];
  f9 = heapClassInst.heapFloat[r0 + numDefine14];
  f5 = f5 + f6;
  r0 = r1 >> numDefine2;
  f1 = f2 + f1;
  f0 = f3 * f0;
  f2 = f7 - f4;
  f0 = f1 + f0;
  f1 = f8 - f5;
  heapClassInst.heapFloat[r0] = f2;
  f2 = f9 - f0;
  heapClassInst.heapFloat[r0 + 1] = f1;
  heapClassInst.heapFloat[r0 + numDefine2] = f2;
  r1 = r2 >> numDefine2;
  f1 = f7 + f4;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  f2 = f8 + f5;
  heapClassInst.heapFloat[r1] = f1;
  f0 = f9 + f0;
  heapClassInst.heapFloat[r1 + 1] = f2;
  heapClassInst.heapFloat[r1 + numDefine2] = f0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  return;
}

function znk14btCapsuleShape28calculateSerializeBufferSizeEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine60;
  commonVariable.rg0 = r0;
  return;
}

function znk14btCapsuleShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine3];
  if (!(r0 < 1)) {
    r1 = heapClassInst.heap32[fp];
    r2 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r2 + numDefine13];
    r4 = (r3 + numDefine2) | 0;
    r4 = r4 % numDefine3 | 0;
    r4 = r4 << numDefine2;
    r4 = (r1 + r4) | 0;
    r4 = r4 >> numDefine2;
    r5 = heapClassInst.heap32[fp + 1];
    r6 = heapClassInst.heap32[fp + numDefine2];
    f0 = heapClassInst.heapFloat[r4 + numDefine7];
    r0 = (r0 + -1) | 0;
    r4 = (r5 + numDefine8) | 0;
    r5 = (r6 + numDefine8) | 0;
    repeat3: while (true) {
      r6 = sp + numDefineNeg16;
      heapClassInst.heap32[fp + numDefineNeg4] = 0;
      r7 = r6 >> numDefine2;
      r3 = r3 << numDefine2;
      heapClassInst.heap32[r7 + 1] = 0;
      r6 = (r6 + r3) | 0;
      r3 = (r1 + r3) | 0;
      heapClassInst.heap32[r7 + numDefine2] = 0;
      r6 = r6 >> numDefine2;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r7 + numDefine3] = 0;
      heapClassInst.heap32[r6] = heapClassInst.heap32[r3 + numDefine7];
      r3 = heapClassInst.heap32[r2];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine11];
      heapClassInst.heap32[g0] = r1;
      functionTable[r3 >> numDefine2](i7);
      r3 = r4 >> numDefine2;
      f2 = heapClassInst.heapFloat[r3 + -1];
      f3 = heapClassInst.heapFloat[r2 + numDefine4];
      f4 = heapClassInst.heapFloat[r3 + numDefineNeg2];
      f5 = heapClassInst.heapFloat[r2 + numDefine3];
      f6 = heapClassInst.heapFloat[r3];
      f7 = heapClassInst.heapFloat[r2 + numDefine5];
      f3 = f2 * f3;
      f5 = f4 * f5;
      f7 = f6 * f7;
      f8 = heapClassInst.heapFloat[r7 + 1];
      f3 = f3 * f0;
      f9 = heapClassInst.heapFloat[fp + numDefineNeg4];
      f5 = f5 * f0;
      f10 = heapClassInst.heapFloat[r7 + numDefine2];
      f7 = f7 * f0;
      f3 = f8 + f3;
      f8 = f2 * commonVariable.fg0;
      f5 = f9 + f5;
      f9 = f4 * commonVariable.fg0;
      f3 = f3 - f8;
      f5 = f5 - f9;
      f7 = f10 + f7;
      f1 = f6 * commonVariable.fg0;
      f1 = f7 - f1;
      f4 = f4 * f5;
      f2 = f2 * f3;
      f2 = f4 + f2;
      f4 = f6 * f1;
      f2 = f2 + f4;
      f4 = numDefineNeg49440;
      if (f2 > f4) {
        r6 = r5 >> numDefine2;
        heapClassInst.heapFloat[r6 + numDefineNeg2] = f5;
        heapClassInst.heapFloat[r6 + -1] = f3;
        heapClassInst.heapFloat[r6] = f1;
        heapClassInst.heap32[r6 + 1] = 0;
        f4 = f2;
      }
      r6 = sp + numDefineNeg32;
      heapClassInst.heap32[fp + numDefineNeg8] = 0;
      r7 = r6 >> numDefine2;
      heapClassInst.heap32[r7 + 1] = 0;
      heapClassInst.heap32[r7 + numDefine2] = 0;
      heapClassInst.heap32[r7 + numDefine3] = 0;
      r8 = heapClassInst.heap32[r2 + numDefine13];
      r8 = r8 << numDefine2;
      r9 = (r1 + r8) | 0;
      r9 = r9 >> numDefine2;
      f1 = heapClassInst.heapFloat[r9 + numDefine7];
      r6 = (r6 + r8) | 0;
      r6 = r6 >> numDefine2;
      f1 = -f1;
      heapClassInst.heapFloat[r6] = f1;
      r6 = heapClassInst.heap32[r2];
      r6 = r6 >> numDefine2;
      r6 = heapClassInst.heap32[r6 + numDefine11];
      heapClassInst.heap32[g0] = r1;
      functionTable[r6 >> numDefine2](i7);
      f2 = heapClassInst.heapFloat[r3 + -1];
      f3 = heapClassInst.heapFloat[r2 + numDefine4];
      f5 = heapClassInst.heapFloat[r3 + numDefineNeg2];
      f6 = heapClassInst.heapFloat[r2 + numDefine3];
      f7 = heapClassInst.heapFloat[r3];
      f8 = heapClassInst.heapFloat[r2 + numDefine5];
      f3 = f2 * f3;
      f6 = f5 * f6;
      f8 = f7 * f8;
      f9 = heapClassInst.heapFloat[r7 + 1];
      f3 = f3 * f0;
      f10 = heapClassInst.heapFloat[fp + numDefineNeg8];
      f6 = f6 * f0;
      f11 = heapClassInst.heapFloat[r7 + numDefine2];
      f8 = f8 * f0;
      f3 = f9 + f3;
      f9 = f2 * commonVariable.fg0;
      f6 = f10 + f6;
      f10 = f5 * commonVariable.fg0;
      f3 = f3 - f9;
      f6 = f6 - f10;
      f8 = f11 + f8;
      f1 = f7 * commonVariable.fg0;
      f1 = f8 - f1;
      f5 = f5 * f6;
      f2 = f2 * f3;
      f2 = f5 + f2;
      f5 = f7 * f1;
      f2 = f2 + f5;
      if (!(f2 <= f4)) {
        r3 = r5 >> numDefine2;
        heapClassInst.heapFloat[r3 + numDefineNeg2] = f6;
        heapClassInst.heapFloat[r3 + -1] = f3;
        heapClassInst.heapFloat[r3] = f1;
        heapClassInst.heap32[r3 + 1] = 0;
      }
      if (r0 === 0) {
        break repeat3;
      } else {
        r3 = heapClassInst.heap32[r2 + numDefine13];
        r0 = (r0 + -1) | 0;
        r4 = (r4 + numDefine16) | 0;
        r5 = (r5 + numDefine16) | 0;
        continue repeat3;
      }
    }
  }
  return;
}

function znk14btCapsuleShape21calculateLocalInertiaEfR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine13];
  r2 = (r1 + numDefine2) | 0;
  r2 = r2 % numDefine3 | 0;
  r0 = (r0 + numDefine28) | 0;
  r2 = r2 << numDefine2;
  r2 = (r0 + r2) | 0;
  r2 = r2 >> numDefine2;
  f0 = heapClassInst.heapFloat[r2];
  r2 = sp + numDefineNeg16;
  r3 = r2 >> numDefine2;
  heapClassInst.heapFloat[fp + numDefineNeg4] = f0;
  r1 = r1 << numDefine2;
  heapClassInst.heapFloat[r3 + 1] = f0;
  r2 = (r2 + r1) | 0;
  r0 = (r0 + r1) | 0;
  heapClassInst.heapFloat[r3 + numDefine2] = f0;
  r1 = r2 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r1];
  f1 = heapClassInst.heapFloat[r0];
  f0 = f0 + f1;
  heapClassInst.heapFloat[r1] = f0;
  f0 = numDefineFloat028;
  f1 = heapClassInst.heapFloat[r3 + 1];
  f2 = heapClassInst.heapFloat[r3 + numDefine2];
  f3 = heapClassInst.heapFloat[fp + numDefineNeg4];
  f1 = f1 + f0;
  f2 = f2 + f0;
  f0 = f3 + f0;
  f1 = f1 + f1;
  f2 = f2 + f2;
  f0 = f0 + f0;
  f1 = f1 * f1;
  f2 = f2 * f2;
  f3 = heapClassInst.heapFloat[fp + 1];
  f4 = numDefineFloat002;
  f0 = f0 * f0;
  r0 = heapClassInst.heap32[fp + numDefine2];
  f5 = f1 + f2;
  f3 = f3 * f4;
  f2 = f0 + f2;
  r0 = r0 >> numDefine2;
  f4 = f5 * f3;
  f0 = f0 + f1;
  f1 = f2 * f3;
  heapClassInst.heapFloat[r0] = f4;
  f0 = f0 * f3;
  heapClassInst.heapFloat[r0 + 1] = f1;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  return;
}

function znk21btConvexInternalShape32getPreferredPenetrationDirectionEiR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr10;
  r1 = twoEStr4198;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = numDefine110;
  assertNew(i7);
}

function znk14btCapsuleShape9serializeEPvP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine10];
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r4 = heapClassInst.heap32[r1];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine7];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  r5 = heapClassInst.heap32[fp + 1];
  functionTable[r4 >> numDefine2](i7);
  r4 = commonVariable.rg0;
  r5 = r5 >> numDefine2;
  heapClassInst.heap32[r5] = r4;
  if (!(r4 === 0)) {
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine12];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    functionTable[r1 >> numDefine2](i7);
  }
  r0 = r3 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + 1];
  heapClassInst.heap32[r5 + 1] = r1;
  heapClassInst.heap32[r5 + numDefine7] = heapClassInst.heap32[r0 + numDefine7];
  heapClassInst.heap32[r5 + numDefine8] = heapClassInst.heap32[r0 + numDefine8];
  heapClassInst.heap32[r5 + numDefine9] = heapClassInst.heap32[r0 + numDefine9];
  heapClassInst.heap32[r5 + numDefine10] = heapClassInst.heap32[r0 + numDefine10];
  heapClassInst.heap32[r5 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
  heapClassInst.heap32[r5 + numDefine4] = heapClassInst.heap32[r0 + numDefine4];
  heapClassInst.heap32[r5 + numDefine5] = heapClassInst.heap32[r0 + numDefine5];
  heapClassInst.heap32[r5 + numDefine6] = heapClassInst.heap32[r0 + numDefine6];
  heapClassInst.heap32[r5 + numDefine11] = heapClassInst.heap32[r0 + numDefine11];
  r0 = heapClassInst.heap32[r0 + numDefine13];
  heapClassInst.heap32[r5 + numDefine13] = r0;
  r0 = twoEStr6199;
  commonVariable.rg0 = r0;
  return;
}

function zn14btCapsuleShape15setLocalScalingERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f1 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f2 = commonVariable.fg0;
  r0 = heapClassInst.heap32[fp + 1];
  f3 = heapClassInst.heapFloat[r1 + numDefine9];
  f4 = heapClassInst.heapFloat[r1 + numDefine8];
  f5 = heapClassInst.heapFloat[r1 + numDefine7];
  r0 = r0 >> numDefine2;
  f3 = f3 + f0;
  f6 = heapClassInst.heapFloat[r1 + numDefine5];
  f4 = f4 + f1;
  f7 = heapClassInst.heapFloat[r1 + numDefine4];
  f5 = f5 + f2;
  f8 = heapClassInst.heapFloat[r1 + numDefine3];
  f9 = heapClassInst.heapFloat[r0 + numDefine2];
  f3 = f3 / f6;
  f4 = f4 / f7;
  f5 = f5 / f8;
  f6 = 0;
  if (f9 < f6) {
    f9 = -f9;
  }
  f7 = heapClassInst.heapFloat[r0 + 1];
  if (f7 < f6) {
    f7 = -f7;
  }
  f8 = heapClassInst.heapFloat[r0];
  if (f8 < f6) {
    f8 = -f8;
  }
  heapClassInst.heapFloat[r1 + numDefine3] = f8;
  heapClassInst.heapFloat[r1 + numDefine4] = f7;
  heapClassInst.heapFloat[r1 + numDefine5] = f9;
  f5 = f5 * f8;
  f4 = f4 * f7;
  f2 = f5 - f2;
  heapClassInst.heap32[r1 + numDefine6] = 0;
  f3 = f3 * f9;
  f1 = f4 - f1;
  heapClassInst.heapFloat[r1 + numDefine7] = f2;
  f0 = f3 - f0;
  heapClassInst.heapFloat[r1 + numDefine8] = f1;
  heapClassInst.heapFloat[r1 + numDefine9] = f0;
  heapClassInst.heap32[r1 + numDefine10] = 0;
  return;
}

function zn14btCapsuleShapeD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  if (!(r0 === 0)) {
    r0 = gNumAlignedFree;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0];
    r1 = (r1 + 1) | 0;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r2 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}

function zn14btCapsuleShapeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function znk14btCapsuleShape37localGetSupportingVertexWithoutMarginERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0] = 0;
  heapClassInst.heap32[r0 + 1] = 0;
  r1 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[r0 + numDefine2] = 0;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  f0 = heapClassInst.heapFloat[r1];
  f1 = heapClassInst.heapFloat[r1 + 1];
  f2 = heapClassInst.heapFloat[r1 + numDefine2];
  f3 = f0 * f0;
  f4 = f1 * f1;
  f3 = f3 + f4;
  f4 = f2 * f2;
  f3 = f3 + f4;
  r1 = heapClassInst.heap32[fp + 1];
  f4 = numDefineFloat9165;
  if (f3 >= f4) {
    heapClassInst.heapFloat[g0] = f3;
    f3 = 1;
    sqrtf(i7);
    f3 = f3 / commonVariable.fg0;
    f0 = f0 * f3;
    f1 = f1 * f3;
    f2 = f2 * f3;
  } else {
    f0 = 1;
    f1 = 0;
    f2 = f1;
  }
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine13];
  r4 = (r3 + numDefine2) | 0;
  r4 = r4 % numDefine3 | 0;
  r5 = (r1 + numDefine28) | 0;
  r4 = r4 << numDefine2;
  r4 = (r5 + r4) | 0;
  r4 = r4 >> numDefine2;
  f3 = heapClassInst.heapFloat[r4];
  r4 = sp + numDefineNeg16;
  heapClassInst.heap32[fp + numDefineNeg4] = 0;
  r6 = r4 >> numDefine2;
  r3 = r3 << numDefine2;
  heapClassInst.heap32[r6 + 1] = 0;
  r4 = (r4 + r3) | 0;
  r3 = (r5 + r3) | 0;
  heapClassInst.heap32[r6 + numDefine2] = 0;
  r4 = r4 >> numDefine2;
  r3 = r3 >> numDefine2;
  heapClassInst.heap32[r6 + numDefine3] = 0;
  heapClassInst.heap32[r4] = heapClassInst.heap32[r3];
  r3 = heapClassInst.heap32[r2];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine11];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  f5 = heapClassInst.heapFloat[r2 + numDefine4];
  f6 = heapClassInst.heapFloat[r2 + numDefine3];
  f7 = heapClassInst.heapFloat[r2 + numDefine5];
  f5 = f1 * f5;
  f6 = f0 * f6;
  f7 = f2 * f7;
  f8 = heapClassInst.heapFloat[r6 + 1];
  f5 = f5 * f3;
  f9 = heapClassInst.heapFloat[fp + numDefineNeg4];
  f6 = f6 * f3;
  f10 = heapClassInst.heapFloat[r6 + numDefine2];
  f7 = f7 * f3;
  f5 = f8 + f5;
  f8 = f1 * commonVariable.fg0;
  f6 = f9 + f6;
  f9 = f0 * commonVariable.fg0;
  f5 = f5 - f8;
  f6 = f6 - f9;
  f7 = f10 + f7;
  f4 = f2 * commonVariable.fg0;
  f4 = f7 - f4;
  f7 = f0 * f6;
  f8 = f1 * f5;
  f7 = f7 + f8;
  f8 = f2 * f4;
  f7 = f7 + f8;
  f8 = numDefineNeg49440;
  if (f7 > f8) {
    heapClassInst.heapFloat[r0] = f6;
    heapClassInst.heapFloat[r0 + 1] = f5;
    heapClassInst.heapFloat[r0 + numDefine2] = f4;
    heapClassInst.heap32[r0 + numDefine3] = 0;
    f8 = f7;
  }
  r3 = sp + numDefineNeg32;
  heapClassInst.heap32[fp + numDefineNeg8] = 0;
  r4 = r3 >> numDefine2;
  heapClassInst.heap32[r4 + 1] = 0;
  heapClassInst.heap32[r4 + numDefine2] = 0;
  heapClassInst.heap32[r4 + numDefine3] = 0;
  r5 = heapClassInst.heap32[r2 + numDefine13];
  r5 = r5 << numDefine2;
  r6 = (r1 + r5) | 0;
  r6 = r6 >> numDefine2;
  f4 = heapClassInst.heapFloat[r6 + numDefine7];
  r3 = (r3 + r5) | 0;
  r3 = r3 >> numDefine2;
  f4 = -f4;
  heapClassInst.heapFloat[r3] = f4;
  r3 = heapClassInst.heap32[r2];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine11];
  heapClassInst.heap32[g0] = r1;
  functionTable[r3 >> numDefine2](i7);
  f5 = heapClassInst.heapFloat[r2 + numDefine4];
  f6 = heapClassInst.heapFloat[r2 + numDefine3];
  f7 = heapClassInst.heapFloat[r2 + numDefine5];
  f5 = f1 * f5;
  f6 = f0 * f6;
  f7 = f2 * f7;
  f9 = heapClassInst.heapFloat[r4 + 1];
  f5 = f5 * f3;
  f10 = heapClassInst.heapFloat[fp + numDefineNeg8];
  f6 = f6 * f3;
  f11 = heapClassInst.heapFloat[r4 + numDefine2];
  f3 = f7 * f3;
  f5 = f9 + f5;
  f7 = f1 * commonVariable.fg0;
  f6 = f10 + f6;
  f9 = f0 * commonVariable.fg0;
  f5 = f5 - f7;
  f6 = f6 - f9;
  f3 = f11 + f3;
  f4 = f2 * commonVariable.fg0;
  f3 = f3 - f4;
  f0 = f0 * f6;
  f1 = f1 * f5;
  f0 = f0 + f1;
  f1 = f2 * f3;
  f0 = f0 + f1;
  if (!(f0 <= f8)) {
    heapClassInst.heapFloat[r0] = f6;
    heapClassInst.heapFloat[r0 + 1] = f5;
    heapClassInst.heapFloat[r0 + numDefine2] = f3;
    heapClassInst.heap32[r0 + numDefine3] = 0;
  }
  return;
}

function znk16btCollisionShape28calculateSerializeBufferSizeEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine12;
  commonVariable.rg0 = r0;
  return;
}

function znk16btCollisionShape27getContactBreakingThresholdEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine4];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  f1 = heapClassInst.heapFloat[fp + 1];
  f0 = commonVariable.fg0 * f1;
  commonVariable.fg0 = f0;
  return;
}

function znk16btCollisionShape9serializeEPvP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine10];
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r4 = heapClassInst.heap32[r1];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine7];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  r5 = heapClassInst.heap32[fp + 1];
  functionTable[r4 >> numDefine2](i7);
  r4 = commonVariable.rg0;
  r5 = r5 >> numDefine2;
  heapClassInst.heap32[r5] = r4;
  if (!(r4 === 0)) {
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine12];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    functionTable[r1 >> numDefine2](i7);
  }
  r0 = r3 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + 1];
  heapClassInst.heap32[r5 + 1] = r0;
  r0 = twoEStr200;
  commonVariable.rg0 = r0;
  return;
}

function znk16btCollisionShape20serializeSingleShapeEP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine12];
  heapClassInst.heap32[g0] = r0;
  r3 = heapClassInst.heap32[fp + 1];
  functionTable[r2 >> numDefine2](i7);
  r4 = r3 >> numDefine2;
  r5 = heapClassInst.heap32[r4];
  r5 = r5 >> numDefine2;
  r5 = heapClassInst.heap32[r5 + numDefine4];
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
  heapClassInst.heap32[g0 + numDefine2] = 1;
  functionTable[r5 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r5 = r2 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine13];
  r5 = heapClassInst.heap32[r5 + numDefine2];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  functionTable[r1 >> numDefine2](i7);
  r4 = heapClassInst.heap32[r4];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine5];
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
  heapClassInst.heap32[g0 + numDefine3] = numDefine55635;
  heapClassInst.heap32[g0 + numDefine4] = r0;
  functionTable[r4 >> numDefine2](i7);
  return;
}

function znk16btCollisionShape17getBoundingSphereER9btVector3Rf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg112;
  let g0 = i7 >> numDefine2;
  r0 = sp + numDefineNeg64;
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
  heapClassInst.heap32[r1 + 1] = 0;
  heapClassInst.heap32[r1 + numDefine2] = 0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  heapClassInst.heap32[r1 + numDefine4] = 0;
  heapClassInst.heap32[r1 + numDefine5] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine6] = 0;
  heapClassInst.heap32[r1 + numDefine7] = 0;
  heapClassInst.heap32[r1 + numDefine8] = 0;
  heapClassInst.heap32[r1 + numDefine9] = 0;
  heapClassInst.heap32[r1 + numDefine10] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine11] = 0;
  heapClassInst.heap32[r1 + numDefine12] = 0;
  heapClassInst.heap32[r1 + numDefine13] = 0;
  r2 = heapClassInst.heap32[fp];
  heapClassInst.heap32[r1 + numDefine14] = 0;
  r3 = r2 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine15] = 0;
  r1 = heapClassInst.heap32[r3];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine2];
  r3 = sp + numDefineNeg96;
  r4 = sp + numDefineNeg80;
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  heapClassInst.heap32[g0 + numDefine3] = r3;
  functionTable[r1 >> numDefine2](i7);
  r0 = r3 >> numDefine2;
  r1 = r4 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + 1];
  f1 = heapClassInst.heapFloat[r1 + 1];
  f2 = heapClassInst.heapFloat[fp + numDefineNeg24];
  f3 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f2 = f2 - f3;
  f0 = f0 - f1;
  f1 = heapClassInst.heapFloat[r0 + numDefine2];
  f3 = heapClassInst.heapFloat[r1 + numDefine2];
  f1 = f1 - f3;
  f2 = f2 * f2;
  f0 = f0 * f0;
  f0 = f2 + f0;
  f1 = f1 * f1;
  f0 = f0 + f1;
  heapClassInst.heapFloat[g0] = f0;
  r2 = heapClassInst.heap32[fp + numDefine2];
  f0 = numDefineFloat05;
  sqrtf(i7);
  r2 = r2 >> numDefine2;
  f1 = commonVariable.fg0 * f0;
  heapClassInst.heapFloat[r2] = f1;
  f1 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f2 = heapClassInst.heapFloat[fp + numDefineNeg24];
  r2 = heapClassInst.heap32[fp + 1];
  f1 = f1 + f2;
  f2 = heapClassInst.heapFloat[r1 + numDefine2];
  f3 = heapClassInst.heapFloat[r0 + numDefine2];
  f4 = heapClassInst.heapFloat[r1 + 1];
  f5 = heapClassInst.heapFloat[r0 + 1];
  f4 = f4 + f5;
  r0 = r2 >> numDefine2;
  f1 = f1 * f0;
  f2 = f2 + f3;
  f3 = f4 * f0;
  heapClassInst.heapFloat[r0] = f1;
  f0 = f2 * f0;
  heapClassInst.heapFloat[r0 + 1] = f3;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk16btCollisionShape20getAngularMotionDiscEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine3];
  r2 = sp + numDefineNeg16;
  r3 = sp + numDefineNeg20;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  functionTable[r1 >> numDefine2](i7);
  r0 = r2 >> numDefine2;
  f0 = heapClassInst.heapFloat[fp + numDefineNeg4];
  f1 = heapClassInst.heapFloat[r0 + 1];
  f2 = heapClassInst.heapFloat[r0 + numDefine2];
  f0 = f0 * f0;
  f1 = f1 * f1;
  f0 = f0 + f1;
  f1 = f2 * f2;
  f0 = f0 + f1;
  heapClassInst.heapFloat[g0] = f0;
  sqrtf(i7);
  f1 = heapClassInst.heapFloat[fp + numDefineNeg5];
  f0 = commonVariable.fg0 + f1;
  commonVariable.fg0 = f0;
  return;
}

function znk16btCollisionShape21calculateTemporalAabbERK11btTransformRK9btVector3S5FRS3S6(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine5];
  r4 = heapClassInst.heap32[fp + numDefine4];
  r5 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  heapClassInst.heap32[g0 + numDefine3] = r3;
  r5 = heapClassInst.heap32[fp + numDefine2];
  functionTable[r2 >> numDefine2](i7);
  r2 = r3 >> numDefine2;
  r3 = r4 >> numDefine2;
  r4 = r5 >> numDefine2;
  f0 = heapClassInst.heapFloat[r4];
  r5 = heapClassInst.heap32[fp + numDefine3];
  f1 = heapClassInst.heapFloat[r2];
  f2 = heapClassInst.heapFloat[r2 + 1];
  f3 = heapClassInst.heapFloat[r2 + numDefine2];
  f4 = heapClassInst.heapFloat[r3];
  f5 = heapClassInst.heapFloat[r3 + 1];
  f6 = heapClassInst.heapFloat[r3 + numDefine2];
  f7 = heapClassInst.heapFloat[r4 + numDefine2];
  f8 = heapClassInst.heapFloat[r4 + 1];
  f9 = 0;
  if (f0 <= f9) {
    f4 = f0 + f4;
  } else {
    f1 = f0 + f1;
  }
  if (f8 <= f9) {
    f5 = f8 + f5;
  } else {
    f2 = f8 + f2;
  }
  if (f7 <= f9) {
    f6 = f7 + f6;
  } else {
    f3 = f7 + f3;
  }
  r4 = r5 >> numDefine2;
  f0 = heapClassInst.heapFloat[r4];
  f7 = heapClassInst.heapFloat[r4 + 1];
  f8 = heapClassInst.heapFloat[r4 + numDefine2];
  f0 = f0 * f0;
  f7 = f7 * f7;
  f0 = f0 + f7;
  f7 = f8 * f8;
  f0 = f0 + f7;
  heapClassInst.heapFloat[g0] = f0;
  sqrtf(i7);
  f0 = commonVariable.fg0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine4];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  heapClassInst.heapFloat[r3] = f4;
  heapClassInst.heapFloat[r3 + 1] = f5;
  heapClassInst.heapFloat[r3 + numDefine2] = f6;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  heapClassInst.heapFloat[r2] = f1;
  heapClassInst.heapFloat[r2 + 1] = f2;
  heapClassInst.heapFloat[r2 + numDefine2] = f3;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  f0 = f0 * commonVariable.fg0;
  f1 = heapClassInst.heapFloat[r3];
  f1 = f1 - f0;
  heapClassInst.heapFloat[r3] = f1;
  f1 = heapClassInst.heapFloat[r3 + 1];
  f1 = f1 - f0;
  heapClassInst.heapFloat[r3 + 1] = f1;
  f1 = heapClassInst.heapFloat[r3 + numDefine2];
  f1 = f1 - f0;
  heapClassInst.heapFloat[r3 + numDefine2] = f1;
  f1 = heapClassInst.heapFloat[r2];
  f1 = f1 + f0;
  heapClassInst.heapFloat[r2] = f1;
  f1 = heapClassInst.heapFloat[r2 + 1];
  f1 = f1 + f0;
  heapClassInst.heapFloat[r2 + 1] = f1;
  f1 = heapClassInst.heapFloat[r2 + numDefine2];
  f0 = f1 + f0;
  heapClassInst.heapFloat[r2 + numDefine2] = f0;
  return;
}

function zn14btConcaveShapeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv14btConcaveShape;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn14btConcaveShapeD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv14btConcaveShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function znk17btConvexHullShape7getNameEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr219;
  commonVariable.rg0 = r0;
  return;
}

function znk17btConvexHullShape28calculateSerializeBufferSizeEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine68;
  commonVariable.rg0 = r0;
  return;
}

function znk17btConvexHullShape12getNumPlanesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znk17btConvexHullShape9getVertexEiR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[r0 + numDefine25];
  r1 = r1 << numDefine4;
  r1 = (r2 + r1) | 0;
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[fp + numDefine2];
  f0 = heapClassInst.heapFloat[r1 + numDefine2];
  f1 = heapClassInst.heapFloat[r0 + numDefine5];
  f2 = heapClassInst.heapFloat[r1 + 1];
  f3 = heapClassInst.heapFloat[r0 + numDefine4];
  f4 = heapClassInst.heapFloat[r1];
  f5 = heapClassInst.heapFloat[r0 + numDefine3];
  r0 = r2 >> numDefine2;
  f4 = f4 * f5;
  f2 = f2 * f3;
  heapClassInst.heapFloat[r0] = f4;
  f0 = f0 * f1;
  heapClassInst.heapFloat[r0 + 1] = f2;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk17btConvexHullShape7getEdgeEiR9btVector3S1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[r0 + numDefine23];
  r3 = r1 % r2 | 0;
  r4 = heapClassInst.heap32[r0 + numDefine25];
  r3 = r3 << numDefine4;
  r3 = (r4 + r3) | 0;
  r3 = r3 >> numDefine2;
  r4 = heapClassInst.heap32[fp + numDefine2];
  f0 = heapClassInst.heapFloat[r3 + numDefine2];
  f1 = heapClassInst.heapFloat[r0 + numDefine5];
  f2 = heapClassInst.heapFloat[r3 + 1];
  f3 = heapClassInst.heapFloat[r0 + numDefine4];
  f4 = heapClassInst.heapFloat[r3];
  f5 = heapClassInst.heapFloat[r0 + numDefine3];
  r3 = r4 >> numDefine2;
  f4 = f4 * f5;
  f2 = f2 * f3;
  heapClassInst.heapFloat[r3] = f4;
  f0 = f0 * f1;
  heapClassInst.heapFloat[r3 + 1] = f2;
  r1 = (r1 + 1) | 0;
  heapClassInst.heapFloat[r3 + numDefine2] = f0;
  heapClassInst.heap32[r3 + numDefine3] = 0;
  r1 = r1 % r2 | 0;
  r2 = heapClassInst.heap32[r0 + numDefine25];
  r1 = r1 << numDefine4;
  r1 = (r2 + r1) | 0;
  r1 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[fp + numDefine3];
  f0 = heapClassInst.heapFloat[r1 + numDefine2];
  f1 = heapClassInst.heapFloat[r0 + numDefine5];
  f2 = heapClassInst.heapFloat[r1 + 1];
  f3 = heapClassInst.heapFloat[r0 + numDefine4];
  f4 = heapClassInst.heapFloat[r1];
  f5 = heapClassInst.heapFloat[r0 + numDefine3];
  r0 = r2 >> numDefine2;
  f4 = f4 * f5;
  f2 = f2 * f3;
  heapClassInst.heapFloat[r0] = f4;
  f0 = f0 * f1;
  heapClassInst.heapFloat[r0 + 1] = f2;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk17btConvexHullShape11getNumEdgesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine23];
  commonVariable.rg0 = r0;
  return;
}

function znk17btConvexHullShape14getNumVerticesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine23];
  commonVariable.rg0 = r0;
  return;
}

function znk17btConvexHullShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine3];
  r1 = heapClassInst.heap32[fp + numDefine2];
  if (!(r0 < 1)) {
    r2 = (r1 + numDefine12) | 0;
    r3 = r0;
    repeat3: while (true) {
      r3 = (r3 + -1) | 0;
      r4 = (r2 + numDefine16) | 0;
      r2 = r2 >> numDefine2;
      heapClassInst.heap32[r2] = numDefineNeg39253;
      r2 = r4;
      if (r3 !== 0) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r2 = heapClassInst.heap32[fp];
  r2 = r2 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine23];
  repeat6: do {
    if (!(r3 < 1)) {
      r3 = heapClassInst.heap32[fp + 1];
      r1 = (r1 + numDefine8) | 0;
      r3 = (r3 + numDefine8) | 0;
      r4 = 0;
      repeat8: while (true) {
        if (!(r0 < 1)) {
          r5 = heapClassInst.heap32[r2 + numDefine25];
          r6 = r4 << numDefine4;
          r5 = (r5 + r6) | 0;
          r5 = r5 >> numDefine2;
          f0 = heapClassInst.heapFloat[r5 + numDefine2];
          f1 = heapClassInst.heapFloat[r2 + numDefine5];
          f2 = heapClassInst.heapFloat[r5 + 1];
          f3 = heapClassInst.heapFloat[r2 + numDefine4];
          f4 = heapClassInst.heapFloat[r5];
          f5 = heapClassInst.heapFloat[r2 + numDefine3];
          f0 = f0 * f1;
          f1 = f2 * f3;
          f2 = f4 * f5;
          r5 = r3;
          r6 = r1;
          r7 = r0;
          repeat12: while (true) {
            r8 = r5 >> numDefine2;
            f3 = heapClassInst.heapFloat[r8 + numDefineNeg2];
            f4 = heapClassInst.heapFloat[r8 + -1];
            f3 = f3 * f2;
            f4 = f4 * f1;
            f5 = heapClassInst.heapFloat[r8];
            f3 = f3 + f4;
            f4 = f5 * f0;
            r8 = r6 >> numDefine2;
            f3 = f3 + f4;
            f4 = heapClassInst.heapFloat[r8 + 1];
            if (!(f4 >= f3)) {
              heapClassInst.heapFloat[r8 + numDefineNeg2] = f2;
              heapClassInst.heapFloat[r8 + -1] = f1;
              heapClassInst.heapFloat[r8] = f0;
              heapClassInst.heapFloat[r8 + 1] = f3;
            }
            r7 = (r7 + -1) | 0;
            r6 = (r6 + numDefine16) | 0;
            r5 = (r5 + numDefine16) | 0;
            if (!(r7 !== 0)) {
              break repeat12;
            }
          }
        }
        r4 = (r4 + 1) | 0;
        r5 = heapClassInst.heap32[r2 + numDefine23];
        if (r5 > r4) {
          continue repeat8;
        } else {
          break repeat6;
        }
      }
    }
  } while (false);
  return;
}

function znk17btConvexHullShape37localGetSupportingVertexWithoutMarginERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0] = 0;
  heapClassInst.heap32[r0 + 1] = 0;
  r1 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[r0 + numDefine2] = 0;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  r2 = heapClassInst.heap32[r1 + numDefine23];
  if (!(r2 < 1)) {
    r3 = heapClassInst.heap32[fp + numDefine2];
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r1 + numDefine25];
    f0 = heapClassInst.heapFloat[r1 + numDefine5];
    f1 = heapClassInst.heapFloat[r1 + numDefine4];
    f2 = heapClassInst.heapFloat[r1 + numDefine3];
    f3 = heapClassInst.heapFloat[r3];
    f4 = heapClassInst.heapFloat[r3 + 1];
    f5 = heapClassInst.heapFloat[r3 + numDefine2];
    r1 = 0;
    f6 = numDefineNeg49440;
    repeat3: while (true) {
      r3 = r1 << numDefine4;
      r3 = (r4 + r3) | 0;
      r3 = r3 >> numDefine2;
      f7 = heapClassInst.heapFloat[r3 + 1];
      f8 = heapClassInst.heapFloat[r3];
      f7 = f7 * f1;
      f8 = f8 * f2;
      f9 = heapClassInst.heapFloat[r3 + numDefine2];
      f9 = f9 * f0;
      f10 = f3 * f8;
      f11 = f4 * f7;
      f10 = f10 + f11;
      f11 = f5 * f9;
      f10 = f10 + f11;
      if (f10 > f6) {
        heapClassInst.heapFloat[r0] = f8;
        heapClassInst.heapFloat[r0 + 1] = f7;
        heapClassInst.heapFloat[r0 + numDefine2] = f9;
        heapClassInst.heap32[r0 + numDefine3] = 0;
        f6 = f10;
      }
      r1 = (r1 + 1) | 0;
      if (r1 < r2) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function znk17btConvexHullShape8isInsideERK9btVector3f(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr10;
  r1 = twoEStr3222;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = numDefine173;
  assertNew(i7);
}

function znk17btConvexHullShape8getPlaneER9btVector3S1I(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr10;
  r1 = twoEStr3222;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = numDefine167;
  assertNew(i7);
}

function zn17btConvexHullShapeD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv17btConvexHullShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine25];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine104];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine25] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine104] = r1;
  heapClassInst.heap32[r2 + numDefine25] = 0;
  r1 = ztv13btConvexShape;
  heapClassInst.heap32[r2 + numDefine23] = 0;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2 + numDefine24] = 0;
  heapClassInst.heap32[r2] = r1;
  if (!(r0 === 0)) {
    r0 = gNumAlignedFree;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0];
    r1 = (r1 + 1) | 0;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r2 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}

function zn17btConvexHullShapeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv17btConvexHullShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine25];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine104];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine25] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine104] = r1;
  heapClassInst.heap32[r2 + numDefine25] = 0;
  r0 = ztv13btConvexShape;
  heapClassInst.heap32[r2 + numDefine23] = 0;
  r0 = (r0 + numDefine8) | 0;
  heapClassInst.heap32[r2 + numDefine24] = 0;
  heapClassInst.heap32[r2] = r0;
  return;
}

function zn17btConvexHullShape15setLocalScalingERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r1];
  heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r1 + 1];
  heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r1 + numDefine2];
  heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r1 + numDefine3];
  heapClassInst.heap32[g0] = r0;
  zn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEv(i7);
  return;
}

function znk17btConvexHullShape9serializeEPvP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine10];
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r4 = heapClassInst.heap32[r1];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine7];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  r5 = heapClassInst.heap32[fp + 1];
  functionTable[r4 >> numDefine2](i7);
  r4 = commonVariable.rg0;
  r5 = r5 >> numDefine2;
  heapClassInst.heap32[r5] = r4;
  if (!(r4 === 0)) {
    r4 = heapClassInst.heap32[r1];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine12];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    functionTable[r4 >> numDefine2](i7);
  }
  r2 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + 1];
  heapClassInst.heap32[r5 + 1] = r3;
  heapClassInst.heap32[r5 + numDefine7] = heapClassInst.heap32[r2 + numDefine7];
  heapClassInst.heap32[r5 + numDefine8] = heapClassInst.heap32[r2 + numDefine8];
  heapClassInst.heap32[r5 + numDefine9] = heapClassInst.heap32[r2 + numDefine9];
  heapClassInst.heap32[r5 + numDefine10] = heapClassInst.heap32[r2 + numDefine10];
  heapClassInst.heap32[r5 + numDefine3] = heapClassInst.heap32[r2 + numDefine3];
  heapClassInst.heap32[r5 + numDefine4] = heapClassInst.heap32[r2 + numDefine4];
  heapClassInst.heap32[r5 + numDefine5] = heapClassInst.heap32[r2 + numDefine5];
  heapClassInst.heap32[r5 + numDefine6] = heapClassInst.heap32[r2 + numDefine6];
  heapClassInst.heap32[r5 + numDefine11] = heapClassInst.heap32[r2 + numDefine11];
  r3 = heapClassInst.heap32[r2 + numDefine23];
  heapClassInst.heap32[r5 + numDefine15] = r3;
  if (r3 === 0) {
    heapClassInst.heap32[r5 + numDefine13] = 0;
    heapClassInst.heap32[r5 + numDefine14] = 0;
    r0 = twoEStr6224;
    commonVariable.rg0 = r0;
    return;
  } else {
    r4 = heapClassInst.heap32[r1];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine7];
    r6 = heapClassInst.heap32[r2 + numDefine25];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r6;
    functionTable[r4 >> numDefine2](i7);
    heapClassInst.heap32[r5 + numDefine13] = commonVariable.rg0;
    heapClassInst.heap32[r5 + numDefine14] = 0;
    r5 = heapClassInst.heap32[r1];
    r5 = r5 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine4];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = numDefine16;
    heapClassInst.heap32[g0 + numDefine2] = r3;
    functionTable[r5 >> numDefine2](i7);
    r5 = commonVariable.rg0;
    if (!(r3 < 1)) {
      r4 = r5 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + numDefine2];
      r6 = 0;
      repeat9: while (true) {
        r7 = r6 << numDefine4;
        r8 = heapClassInst.heap32[r2 + numDefine25];
        r9 = (r4 + r7) | 0;
        r7 = (r8 + r7) | 0;
        r8 = r9 >> numDefine2;
        r7 = r7 >> numDefine2;
        heapClassInst.heap32[r8] = heapClassInst.heap32[r7];
        heapClassInst.heap32[r8 + 1] = heapClassInst.heap32[r7 + 1];
        r6 = (r6 + 1) | 0;
        heapClassInst.heap32[r8 + numDefine2] = heapClassInst.heap32[r7 + numDefine2];
        heapClassInst.heap32[r8 + numDefine3] = heapClassInst.heap32[r7 + numDefine3];
        if (!(r3 !== r6)) {
          break repeat9;
        }
      }
    }
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine5];
    r2 = heapClassInst.heap32[r2 + numDefine25];
    r3 = twoEStr5223;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r5;
    heapClassInst.heap32[g0 + numDefine2] = r3;
    heapClassInst.heap32[g0 + numDefine3] = numDefine53121;
    heapClassInst.heap32[g0 + numDefine4] = r2;
    functionTable[r1 >> numDefine2](i7);
    r5 = twoEStr6224;
    commonVariable.rg0 = r5;
    return;
  }
}

function znk17btConvexHullShape24localGetSupportingVertexERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine16];
  r3 = heapClassInst.heap32[fp];
  r4 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  functionTable[r2 >> numDefine2](i7);
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  f1 = 0;
  if (!(f0 === f1)) {
    r2 = r4 >> numDefine2;
    f0 = heapClassInst.heapFloat[r2];
    f1 = heapClassInst.heapFloat[r2 + 1];
    f2 = heapClassInst.heapFloat[r2 + numDefine2];
    f3 = f0 * f0;
    f4 = f1 * f1;
    f3 = f3 + f4;
    f4 = f2 * f2;
    f3 = f3 + f4;
    f4 = numDefineFloat4044;
    f5 = -1;
    f0 = f3 < f4 ? f5 : f0;
    f1 = f3 < f4 ? f5 : f1;
    f2 = f3 < f4 ? f5 : f2;
    f3 = f0 * f0;
    f4 = f1 * f1;
    f3 = f3 + f4;
    f4 = f2 * f2;
    f3 = f3 + f4;
    heapClassInst.heapFloat[g0] = f3;
    sqrtf(i7);
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine11];
    f4 = 1;
    f3 = f4 / commonVariable.fg0;
    heapClassInst.heap32[g0] = r0;
    r0 = r3 >> numDefine2;
    functionTable[r1 >> numDefine2](i7);
    f0 = f0 * f3;
    f0 = f0 * commonVariable.fg0;
    f5 = heapClassInst.heapFloat[r0];
    f0 = f5 + f0;
    f1 = f1 * f3;
    heapClassInst.heapFloat[r0] = f0;
    f0 = f1 * commonVariable.fg0;
    f1 = heapClassInst.heapFloat[r0 + 1];
    f0 = f1 + f0;
    f1 = f2 * f3;
    heapClassInst.heapFloat[r0 + 1] = f0;
    f0 = f1 * commonVariable.fg0;
    f1 = heapClassInst.heapFloat[r0 + numDefine2];
    f0 = f1 + f0;
    heapClassInst.heapFloat[r0 + numDefine2] = f0;
  }
  return;
}

function zn17btConvexHullShape8addPointERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine24];
  r3 = heapClassInst.heap32[r1 + numDefine23];
  r4 = heapClassInst.heap32[fp + 1];
  if (r2 === r3) {
    r5 = 1;
    r6 = r3 << 1;
    r6 = r3 === 0 ? r5 : r6;
    if (!(r2 >= r6)) {
      if (r6 !== 0) {
        r2 = gNumAlignedAllocs;
        r2 = r2 >> numDefine2;
        r7 = heapClassInst.heap32[r2];
        r8 = r6 << numDefine4;
        r7 = (r7 + 1) | 0;
        r8 = r8 | numDefine3;
        heapClassInst.heap32[r2] = r7;
        r2 = (r8 + numDefine16) | 0;
        heapClassInst.heap32[g0] = r2;
        mallocNew(i7);
        r2 = commonVariable.rg0;
        if (r2 !== 0) {
          r7 = 0;
          r8 = (r2 + numDefine4) | 0;
          r7 = (r7 - r8) | 0;
          r7 = r7 & numDefine15;
          r7 = (r2 + r7) | 0;
          r8 = (r7 + numDefine4) | 0;
          r7 = r7 >> numDefine2;
          heapClassInst.heap32[r7] = r2;
          r2 = r8;
        }
      } else {
        r2 = 0;
      }
      r7 = (r0 + numDefine100) | 0;
      if (r3 < 1) {
        r8 = r7 >> numDefine2;
        r9 = heapClassInst.heap32[r8];
      } else {
        r8 = 0;
        repeat12: while (true) {
          r9 = r7 >> numDefine2;
          r9 = heapClassInst.heap32[r9];
          r10 = r8 << numDefine4;
          r11 = (r2 + r10) | 0;
          r10 = (r9 + r10) | 0;
          r11 = r11 >> numDefine2;
          r10 = r10 >> numDefine2;
          heapClassInst.heap32[r11] = heapClassInst.heap32[r10];
          heapClassInst.heap32[r11 + 1] = heapClassInst.heap32[r10 + 1];
          r8 = (r8 + 1) | 0;
          heapClassInst.heap32[r11 + numDefine2] = heapClassInst.heap32[r10 + numDefine2];
          heapClassInst.heap32[r11 + numDefine3] = heapClassInst.heap32[r10 + numDefine3];
          if (!(r3 !== r8)) {
            break repeat12;
          }
        }
        r7 = (r0 + numDefine100) | 0;
      }
      if (r9 !== 0) {
        r8 = heapClassInst.heapU8[r0 + numDefine104];
        if (r8 !== 0) {
          r3 = gNumAlignedFree;
          r3 = r3 >> numDefine2;
          r8 = heapClassInst.heap32[r3];
          r8 = (r8 + 1) | 0;
          r9 = r9 >> numDefine2;
          heapClassInst.heap32[r3] = r8;
          r3 = heapClassInst.heap32[r9 + -1];
          heapClassInst.heap32[g0] = r3;
          free(i7);
          r3 = heapClassInst.heap32[r1 + numDefine23];
        }
        r8 = r7 >> numDefine2;
        heapClassInst.heap32[r8] = 0;
      }
      r7 = r7 >> numDefine2;
      heapClassInst.heap8[r0 + numDefine104] = r5;
      heapClassInst.heap32[r7] = r2;
      heapClassInst.heap32[r1 + numDefine24] = r6;
    }
  }
  r2 = r3 << numDefine4;
  r3 = heapClassInst.heap32[r1 + numDefine25];
  r2 = (r3 + r2) | 0;
  r2 = r2 >> numDefine2;
  r3 = r4 >> numDefine2;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r3];
  heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r3 + 1];
  heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r3 + numDefine2];
  heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r3 + numDefine3];
  r2 = heapClassInst.heap32[r1 + numDefine23];
  r2 = (r2 + 1) | 0;
  heapClassInst.heap32[r1 + numDefine23] = r2;
  heapClassInst.heap32[g0] = r0;
  zn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEv(i7);
  return;
}

function zn20btAlignedObjectArrayI9btVector3E6resizeEiRKS0(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + 1];
  r3 = heapClassInst.heap32[fp + 1];
  repeat1: do {
    if (!(r2 > r3)) {
      if (!(r2 >= r3)) {
        r4 = heapClassInst.heap32[r1 + numDefine2];
        if (!(r4 >= r3)) {
          if (r3 !== 0) {
            r4 = gNumAlignedAllocs;
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r4];
            r6 = r3 << numDefine4;
            r5 = (r5 + 1) | 0;
            r6 = r6 | numDefine3;
            heapClassInst.heap32[r4] = r5;
            r4 = (r6 + numDefine16) | 0;
            heapClassInst.heap32[g0] = r4;
            mallocNew(i7);
            r4 = commonVariable.rg0;
            if (r4 !== 0) {
              r5 = 0;
              r6 = (r4 + numDefine4) | 0;
              r5 = (r5 - r6) | 0;
              r5 = r5 & numDefine15;
              r5 = (r4 + r5) | 0;
              r6 = (r5 + numDefine4) | 0;
              r5 = r5 >> numDefine2;
              heapClassInst.heap32[r5] = r4;
              r4 = r6;
            }
          } else {
            r4 = 0;
          }
          r5 = (r0 + numDefine12) | 0;
          if (r2 < 1) {
            r6 = r5 >> numDefine2;
            r7 = heapClassInst.heap32[r6];
          } else {
            r6 = 0;
            repeat14: while (true) {
              r7 = r5 >> numDefine2;
              r7 = heapClassInst.heap32[r7];
              r8 = r6 << numDefine4;
              r9 = (r4 + r8) | 0;
              r8 = (r7 + r8) | 0;
              r9 = r9 >> numDefine2;
              r8 = r8 >> numDefine2;
              heapClassInst.heap32[r9] = heapClassInst.heap32[r8];
              heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r8 + 1];
              r6 = (r6 + 1) | 0;
              heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r8 + numDefine2];
              heapClassInst.heap32[r9 + numDefine3] = heapClassInst.heap32[r8 + numDefine3];
              if (!(r2 !== r6)) {
                break repeat14;
              }
            }
            r5 = (r0 + numDefine12) | 0;
          }
          if (!(r7 === 0)) {
            r6 = heapClassInst.heapU8[r0 + numDefine16];
            if (!(r6 === 0)) {
              r6 = gNumAlignedFree;
              r6 = r6 >> numDefine2;
              r8 = heapClassInst.heap32[r6];
              r8 = (r8 + 1) | 0;
              r7 = r7 >> numDefine2;
              heapClassInst.heap32[r6] = r8;
              r6 = heapClassInst.heap32[r7 + -1];
              heapClassInst.heap32[g0] = r6;
              free(i7);
            }
            r6 = r5 >> numDefine2;
            heapClassInst.heap32[r6] = 0;
          }
          r6 = 1;
          r5 = r5 >> numDefine2;
          heapClassInst.heap8[r0 + numDefine16] = r6;
          heapClassInst.heap32[r5] = r4;
          heapClassInst.heap32[r1 + numDefine2] = r3;
          if (r2 >= r3) {
            break repeat1;
          }
        }
        r0 = heapClassInst.heap32[fp + numDefine2];
        repeat25: while (true) {
          r4 = r2 << numDefine4;
          r5 = heapClassInst.heap32[r1 + numDefine3];
          r4 = (r5 + r4) | 0;
          r4 = r4 >> numDefine2;
          r5 = r0 >> numDefine2;
          heapClassInst.heap32[r4] = heapClassInst.heap32[r5];
          heapClassInst.heap32[r4 + 1] = heapClassInst.heap32[r5 + 1];
          r2 = (r2 + 1) | 0;
          heapClassInst.heap32[r4 + numDefine2] = heapClassInst.heap32[r5 + numDefine2];
          heapClassInst.heap32[r4 + numDefine3] = heapClassInst.heap32[r5 + numDefine3];
          if (r3 !== r2) {
            continue repeat25;
          } else {
            break repeat1;
          }
        }
      }
    }
  } while (false);
  heapClassInst.heap32[r1 + 1] = r3;
  return;
}

function zn17btConvexHullShapeC1EPKfii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  heapClassInst.heap32[r1 + numDefine2] = 0;
  heapClassInst.heap32[r1 + numDefine3] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine4] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine5] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine6] = 0;
  heapClassInst.heap32[r1 + numDefine11] = numDefine58986;
  heapClassInst.heap32[r1 + numDefine13] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine14] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine15] = numDefine53216;
  heapClassInst.heap32[r1 + numDefine16] = 0;
  heapClassInst.heap32[r1 + numDefine17] = numDefineNeg30432;
  heapClassInst.heap32[r1 + numDefine18] = numDefineNeg30432;
  heapClassInst.heap32[r1 + numDefine19] = numDefineNeg30432;
  r2 = ztv17btConvexHullShape;
  r3 = 0;
  heapClassInst.heap32[r1 + numDefine20] = 0;
  r2 = (r2 + numDefine8) | 0;
  heapClassInst.heap8[r0 + numDefine84] = r3;
  r4 = 1;
  heapClassInst.heap32[r1] = r2;
  heapClassInst.heap8[r0 + numDefine104] = r4;
  heapClassInst.heap32[r1 + numDefine25] = 0;
  heapClassInst.heap32[r1 + numDefine23] = 0;
  heapClassInst.heap32[r1 + numDefine24] = 0;
  heapClassInst.heap32[r1 + 1] = numDefine4;
  r2 = heapClassInst.heap32[fp + numDefine2];
  r4 = (r0 + numDefine88) | 0;
  r5 = sp + numDefineNeg16;
  heapClassInst.heap32[g0] = r4;
  heapClassInst.heap32[g0 + 1] = r2;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  zn20btAlignedObjectArrayI9btVector3E6resizeEiRKS0(i7);
  if (!(r2 < 1)) {
    r4 = heapClassInst.heap32[fp + 1];
    repeat3: while (true) {
      r5 = r3 << numDefine4;
      r6 = (r4 + r5) | 0;
      r6 = r6 >> numDefine2;
      r7 = heapClassInst.heap32[r1 + numDefine25];
      r5 = (r7 + r5) | 0;
      f0 = heapClassInst.heapFloat[r6 + numDefine2];
      f1 = heapClassInst.heapFloat[r6 + 1];
      r5 = r5 >> numDefine2;
      heapClassInst.heap32[r5] = heapClassInst.heap32[r6];
      heapClassInst.heapFloat[r5 + 1] = f1;
      r3 = (r3 + 1) | 0;
      heapClassInst.heapFloat[r5 + numDefine2] = f0;
      heapClassInst.heap32[r5 + numDefine3] = 0;
      if (r2 !== r3) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  heapClassInst.heap32[g0] = r0;
  zn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEv(i7);
  return;
}

function zn21btConvexInternalShape15setLocalScalingERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine2];
  r1 = heapClassInst.heap32[fp];
  f1 = 0;
  if (f0 < f1) {
    f0 = -f0;
  }
  f2 = heapClassInst.heapFloat[r0 + 1];
  if (f2 < f1) {
    f2 = -f2;
  }
  f3 = heapClassInst.heapFloat[r0];
  if (f3 < f1) {
    f3 = -f3;
  }
  r0 = r1 >> numDefine2;
  heapClassInst.heapFloat[r0 + numDefine3] = f3;
  heapClassInst.heapFloat[r0 + numDefine4] = f2;
  heapClassInst.heapFloat[r0 + numDefine5] = f0;
  heapClassInst.heap32[r0 + numDefine6] = 0;
  return;
}

function znk21btConvexInternalShape11getAabbSlowERK11btTransformR9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg112;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  r3 = heapClassInst.heap32[fp + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  r5 = heapClassInst.heap32[fp + numDefine3];
  r6 = 0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  repeat1: while (true) {
    r2 = sp + numDefineNeg64;
    r7 = r2 >> numDefine2;
    heapClassInst.heap32[fp + numDefineNeg16] = 0;
    heapClassInst.heap32[r7 + 1] = 0;
    r8 = r6 << numDefine2;
    r2 = (r2 - r8) | 0;
    heapClassInst.heap32[r7 + numDefine2] = 0;
    r2 = r2 >> numDefine2;
    heapClassInst.heap32[r7 + numDefine3] = 0;
    heapClassInst.heap32[r2] = numDefine53216;
    r9 = r3 >> numDefine2;
    r10 = heapClassInst.heap32[r1];
    f1 = heapClassInst.heapFloat[fp + numDefineNeg16];
    f2 = heapClassInst.heapFloat[r9];
    f3 = heapClassInst.heapFloat[r7 + 1];
    f4 = heapClassInst.heapFloat[r9 + numDefine4];
    r10 = r10 >> numDefine2;
    f5 = heapClassInst.heapFloat[r9 + 1];
    f6 = heapClassInst.heapFloat[r9 + numDefine5];
    f2 = f2 * f1;
    f4 = f4 * f3;
    f7 = heapClassInst.heapFloat[r7 + numDefine2];
    f8 = heapClassInst.heapFloat[r9 + numDefine8];
    f9 = heapClassInst.heapFloat[r9 + numDefine2];
    f10 = heapClassInst.heapFloat[r9 + numDefine6];
    f11 = heapClassInst.heapFloat[r9 + numDefine10];
    f12 = heapClassInst.heapFloat[r9 + numDefine9];
    r10 = heapClassInst.heap32[r10 + numDefine15];
    f5 = f5 * f1;
    f6 = f6 * f3;
    f2 = f2 + f4;
    f4 = f8 * f7;
    r11 = sp + numDefineNeg48;
    f1 = f9 * f1;
    f3 = f10 * f3;
    f5 = f5 + f6;
    f6 = f12 * f7;
    f2 = f2 + f4;
    r12 = r11 >> numDefine2;
    f1 = f1 + f3;
    f3 = f11 * f7;
    f4 = f5 + f6;
    heapClassInst.heapFloat[fp + numDefineNeg12] = f2;
    f1 = f1 + f3;
    heapClassInst.heapFloat[r12 + 1] = f4;
    heapClassInst.heapFloat[r12 + numDefine2] = f1;
    heapClassInst.heap32[r12 + numDefine3] = 0;
    r12 = sp + numDefineNeg80;
    heapClassInst.heap32[g0] = r12;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r11;
    functionTable[r10 >> numDefine2](i7);
    r10 = r12 >> numDefine2;
    f1 = heapClassInst.heapFloat[fp + numDefineNeg20];
    f2 = heapClassInst.heapFloat[r9];
    f3 = heapClassInst.heapFloat[r10 + 1];
    f4 = heapClassInst.heapFloat[r9 + 1];
    f5 = heapClassInst.heapFloat[r9 + numDefine4];
    f6 = heapClassInst.heapFloat[r9 + numDefine5];
    f2 = f2 * f1;
    f4 = f4 * f3;
    f7 = heapClassInst.heapFloat[r10 + numDefine2];
    f8 = heapClassInst.heapFloat[r9 + numDefine2];
    f9 = heapClassInst.heapFloat[r9 + numDefine8];
    f10 = heapClassInst.heapFloat[r9 + numDefine9];
    f11 = heapClassInst.heapFloat[r9 + numDefine6];
    f5 = f5 * f1;
    f6 = f6 * f3;
    f2 = f2 + f4;
    f4 = f8 * f7;
    f8 = heapClassInst.heapFloat[r9 + numDefine10];
    f1 = f9 * f1;
    f3 = f10 * f3;
    f5 = f5 + f6;
    f6 = f11 * f7;
    f2 = f2 + f4;
    f4 = heapClassInst.heapFloat[r9 + numDefine12];
    f9 = heapClassInst.heapFloat[r9 + numDefine14];
    f10 = heapClassInst.heapFloat[r9 + numDefine13];
    r10 = sp + numDefineNeg96;
    f5 = f5 + f6;
    f1 = f1 + f3;
    f3 = f8 * f7;
    f2 = f2 + f4;
    f1 = f1 + f3;
    f3 = f5 + f10;
    heapClassInst.heapFloat[fp + numDefineNeg24] = f2;
    r11 = r10 >> numDefine2;
    f1 = f1 + f9;
    heapClassInst.heapFloat[r11 + 1] = f3;
    heapClassInst.heapFloat[r11 + numDefine2] = f1;
    r10 = (r10 - r8) | 0;
    heapClassInst.heap32[r11 + numDefine3] = 0;
    r10 = r10 >> numDefine2;
    r12 = (r5 - r8) | 0;
    f1 = heapClassInst.heapFloat[r10];
    r12 = r12 >> numDefine2;
    f1 = f1 + f0;
    heapClassInst.heapFloat[r12] = f1;
    heapClassInst.heap32[r2] = numDefineNeg30432;
    r2 = heapClassInst.heap32[r1];
    f1 = heapClassInst.heapFloat[fp + numDefineNeg16];
    f2 = heapClassInst.heapFloat[r9];
    f3 = heapClassInst.heapFloat[r7 + 1];
    f4 = heapClassInst.heapFloat[r9 + numDefine4];
    r2 = r2 >> numDefine2;
    f5 = heapClassInst.heapFloat[r9 + 1];
    f6 = heapClassInst.heapFloat[r9 + numDefine5];
    f2 = f2 * f1;
    f4 = f4 * f3;
    f7 = heapClassInst.heapFloat[r7 + numDefine2];
    f8 = heapClassInst.heapFloat[r9 + numDefine8];
    f9 = heapClassInst.heapFloat[r9 + numDefine2];
    f10 = heapClassInst.heapFloat[r9 + numDefine6];
    f11 = heapClassInst.heapFloat[r9 + numDefine10];
    f12 = heapClassInst.heapFloat[r9 + numDefine9];
    r2 = heapClassInst.heap32[r2 + numDefine15];
    f5 = f5 * f1;
    f6 = f6 * f3;
    f2 = f2 + f4;
    f4 = f8 * f7;
    r7 = sp + numDefineNeg16;
    f1 = f9 * f1;
    f3 = f10 * f3;
    f5 = f5 + f6;
    f6 = f12 * f7;
    f2 = f2 + f4;
    r12 = r7 >> numDefine2;
    f1 = f1 + f3;
    f3 = f11 * f7;
    f4 = f5 + f6;
    heapClassInst.heapFloat[fp + numDefineNeg4] = f2;
    f1 = f1 + f3;
    heapClassInst.heapFloat[r12 + 1] = f4;
    heapClassInst.heapFloat[r12 + numDefine2] = f1;
    heapClassInst.heap32[r12 + numDefine3] = 0;
    r12 = sp + numDefineNeg32;
    heapClassInst.heap32[g0] = r12;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r7;
    functionTable[r2 >> numDefine2](i7);
    r2 = r12 >> numDefine2;
    f1 = heapClassInst.heapFloat[fp + numDefineNeg8];
    f2 = heapClassInst.heapFloat[r9];
    f3 = heapClassInst.heapFloat[r2 + 1];
    f4 = heapClassInst.heapFloat[r9 + 1];
    f5 = heapClassInst.heapFloat[r9 + numDefine4];
    f6 = heapClassInst.heapFloat[r9 + numDefine5];
    f2 = f2 * f1;
    f4 = f4 * f3;
    f7 = heapClassInst.heapFloat[r2 + numDefine2];
    f8 = heapClassInst.heapFloat[r9 + numDefine2];
    f9 = heapClassInst.heapFloat[r9 + numDefine8];
    f10 = heapClassInst.heapFloat[r9 + numDefine9];
    f11 = heapClassInst.heapFloat[r9 + numDefine6];
    f5 = f5 * f1;
    f6 = f6 * f3;
    f2 = f2 + f4;
    f4 = f8 * f7;
    f8 = heapClassInst.heapFloat[r9 + numDefine10];
    f1 = f9 * f1;
    f3 = f10 * f3;
    f5 = f5 + f6;
    f6 = f11 * f7;
    f2 = f2 + f4;
    f4 = heapClassInst.heapFloat[r9 + numDefine12];
    f9 = heapClassInst.heapFloat[r9 + numDefine14];
    f10 = heapClassInst.heapFloat[r9 + numDefine13];
    f5 = f5 + f6;
    f1 = f1 + f3;
    f3 = f8 * f7;
    f2 = f2 + f4;
    f1 = f1 + f3;
    f3 = f5 + f10;
    heapClassInst.heapFloat[fp + numDefineNeg24] = f2;
    f1 = f1 + f9;
    heapClassInst.heapFloat[r11 + 1] = f3;
    heapClassInst.heapFloat[r11 + numDefine2] = f1;
    heapClassInst.heap32[r11 + numDefine3] = 0;
    r2 = (r4 - r8) | 0;
    f1 = heapClassInst.heapFloat[r10];
    r6 = (r6 + -1) | 0;
    r2 = r2 >> numDefine2;
    f1 = f1 - f0;
    heapClassInst.heapFloat[r2] = f1;
    if (r6 !== numDefineNeg3) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  return;
}

function znk21btConvexInternalShape24localGetSupportingVertexERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine16];
  r3 = heapClassInst.heap32[fp];
  r4 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  functionTable[r2 >> numDefine2](i7);
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  f1 = 0;
  if (!(f0 === f1)) {
    r2 = r4 >> numDefine2;
    f0 = heapClassInst.heapFloat[r2];
    f1 = heapClassInst.heapFloat[r2 + 1];
    f2 = heapClassInst.heapFloat[r2 + numDefine2];
    f3 = f0 * f0;
    f4 = f1 * f1;
    f3 = f3 + f4;
    f4 = f2 * f2;
    f3 = f3 + f4;
    f4 = numDefineFloat4044;
    f5 = -1;
    f0 = f3 < f4 ? f5 : f0;
    f1 = f3 < f4 ? f5 : f1;
    f2 = f3 < f4 ? f5 : f2;
    f3 = f0 * f0;
    f4 = f1 * f1;
    f3 = f3 + f4;
    f4 = f2 * f2;
    f3 = f3 + f4;
    heapClassInst.heapFloat[g0] = f3;
    sqrtf(i7);
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine11];
    f4 = 1;
    f3 = f4 / commonVariable.fg0;
    heapClassInst.heap32[g0] = r0;
    r0 = r3 >> numDefine2;
    functionTable[r1 >> numDefine2](i7);
    f0 = f0 * f3;
    f0 = f0 * commonVariable.fg0;
    f5 = heapClassInst.heapFloat[r0];
    f0 = f5 + f0;
    f1 = f1 * f3;
    heapClassInst.heapFloat[r0] = f0;
    f0 = f1 * commonVariable.fg0;
    f1 = heapClassInst.heapFloat[r0 + 1];
    f0 = f1 + f0;
    f1 = f2 * f3;
    heapClassInst.heapFloat[r0 + 1] = f0;
    f0 = f1 * commonVariable.fg0;
    f1 = heapClassInst.heapFloat[r0 + numDefine2];
    f0 = f1 + f0;
    heapClassInst.heapFloat[r0 + numDefine2] = f0;
  }
  return;
}

function zn13btConvexShapeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn13btConvexShapeD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  if (!(r0 === 0)) {
    r0 = gNumAlignedFree;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0];
    r1 = (r1 + 1) | 0;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r2 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}

function zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN20NodeTriangleCallbackD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv31btInternalTriangleIndexCallback;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN20NodeTriangleCallbackD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv31btInternalTriangleIndexCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN20NodeTriangleCallback28internalProcessTriangleIndexEPS2Ii(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp];
  r1 = r1 >> numDefine2;
  f0 = numDefine49440;
  f1 = heapClassInst.heapFloat[r0];
  f2 = heapClassInst.heapFloat[r0 + 1];
  f3 = numDefineNeg49440;
  f4 = heapClassInst.heapFloat[r0 + numDefine2];
  f5 = heapClassInst.heapFloat[r0 + numDefine3];
  f6 = 0;
  r1 = heapClassInst.heap32[r1 + 1];
  f7 = f1 < f0 ? f1 : f0;
  f8 = heapClassInst.heapFloat[r0 + numDefine4];
  f1 = f1 > f3 ? f1 : f3;
  f9 = f2 < f0 ? f2 : f0;
  f10 = heapClassInst.heapFloat[r0 + numDefine5];
  f2 = f2 > f3 ? f2 : f3;
  f0 = f4 < f0 ? f4 : f0;
  f11 = heapClassInst.heapFloat[r0 + numDefine6];
  f3 = f4 > f3 ? f4 : f3;
  f4 = f5 < f6 ? f5 : f6;
  f12 = heapClassInst.heapFloat[r0 + numDefine7];
  f5 = f5 > f6 ? f5 : f6;
  r2 = r1 >> numDefine2;
  f6 = f8 < f7 ? f8 : f7;
  f7 = heapClassInst.heapFloat[r0 + numDefine8];
  f1 = f1 < f8 ? f8 : f1;
  f8 = f10 < f9 ? f10 : f9;
  f9 = heapClassInst.heapFloat[r0 + numDefine9];
  f2 = f2 < f10 ? f10 : f2;
  f0 = f11 < f0 ? f11 : f0;
  f10 = heapClassInst.heapFloat[r0 + numDefine10];
  f3 = f3 < f11 ? f11 : f3;
  f4 = f12 < f4 ? f12 : f4;
  f11 = heapClassInst.heapFloat[r0 + numDefine11];
  f5 = f5 < f12 ? f12 : f5;
  r0 = heapClassInst.heap32[r2 + numDefine2];
  r3 = heapClassInst.heap32[r2 + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  r5 = heapClassInst.heap32[fp + numDefine3];
  f6 = f7 < f6 ? f7 : f6;
  f8 = f9 < f8 ? f9 : f8;
  f0 = f10 < f0 ? f10 : f0;
  f4 = f11 < f4 ? f11 : f4;
  f1 = f1 < f7 ? f7 : f1;
  f2 = f2 < f9 ? f9 : f2;
  f3 = f3 < f10 ? f10 : f3;
  f5 = f5 < f11 ? f11 : f5;
  if (r0 === r3) {
    r6 = 1;
    r7 = r3 << 1;
    r7 = r3 === 0 ? r6 : r7;
    if (!(r0 >= r7)) {
      if (r7 !== 0) {
        r0 = gNumAlignedAllocs;
        r0 = r0 >> numDefine2;
        r8 = heapClassInst.heap32[r0];
        r8 = (r8 + 1) | 0;
        r9 = r7 << numDefine6;
        heapClassInst.heap32[r0] = r8;
        r0 = r9 | numDefine19;
        heapClassInst.heap32[g0] = r0;
        mallocNew(i7);
        r0 = commonVariable.rg0;
        if (r0 !== 0) {
          r3 = 0;
          r8 = (r0 + numDefine4) | 0;
          r3 = (r3 - r8) | 0;
          r3 = r3 & numDefine15;
          r3 = (r0 + r3) | 0;
          r8 = r3 >> numDefine2;
          heapClassInst.heap32[r8] = r0;
          r0 = (r3 + numDefine4) | 0;
          r3 = heapClassInst.heap32[r2 + 1];
        }
      } else {
        r0 = 0;
      }
      if (!(r3 < 1)) {
        r8 = 0;
        repeat11: while (true) {
          r9 = heapClassInst.heap32[r2 + numDefine3];
          r10 = (r0 + r8) | 0;
          r9 = (r9 + r8) | 0;
          heapClassInst.heap32[g0] = r10;
          heapClassInst.heap32[g0 + 1] = r9;
          heapClassInst.heap32[g0 + numDefine2] = numDefine64;
          r3 = (r3 + -1) | 0;
          r8 = (r8 + numDefine64) | 0;
          memcpy(i7);
          if (!(r3 !== 0)) {
            break repeat11;
          }
        }
      }
      r3 = heapClassInst.heap32[r2 + numDefine3];
      if (!(r3 === 0)) {
        r8 = heapClassInst.heapU8[r1 + numDefine16];
        if (!(r8 === 0)) {
          r8 = gNumAlignedFree;
          r8 = r8 >> numDefine2;
          r9 = heapClassInst.heap32[r8];
          r9 = (r9 + 1) | 0;
          r3 = r3 >> numDefine2;
          heapClassInst.heap32[r8] = r9;
          r3 = heapClassInst.heap32[r3 + -1];
          heapClassInst.heap32[g0] = r3;
          free(i7);
        }
        heapClassInst.heap32[r2 + numDefine3] = 0;
      }
      heapClassInst.heap8[r1 + numDefine16] = r6;
      heapClassInst.heap32[r2 + numDefine3] = r0;
      heapClassInst.heap32[r2 + numDefine2] = r7;
      r3 = heapClassInst.heap32[r2 + 1];
    }
  }
  r0 = r3 << numDefine6;
  r1 = heapClassInst.heap32[r2 + numDefine3];
  r0 = (r1 + r0) | 0;
  r0 = r0 >> numDefine2;
  heapClassInst.heapFloat[r0] = f6;
  heapClassInst.heapFloat[r0 + 1] = f8;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heapFloat[r0 + numDefine3] = f4;
  heapClassInst.heapFloat[r0 + numDefine4] = f1;
  heapClassInst.heapFloat[r0 + numDefine5] = f2;
  heapClassInst.heapFloat[r0 + numDefine6] = f3;
  heapClassInst.heapFloat[r0 + numDefine7] = f5;
  heapClassInst.heap32[r0 + numDefine8] = -1;
  heapClassInst.heap32[r0 + numDefine9] = r4;
  heapClassInst.heap32[r0 + numDefine10] = r5;
  r0 = heapClassInst.heap32[r2 + 1];
  r0 = (r0 + 1) | 0;
  heapClassInst.heap32[r2 + 1] = r0;
  return;
}

function zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN29QuantizedNodeTriangleCallbackD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv31btInternalTriangleIndexCallback;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN29QuantizedNodeTriangleCallbackD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv31btInternalTriangleIndexCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN29QuantizedNodeTriangleCallback28internalProcessTriangleIndexEPS2Ii(
  sp: number
): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg64;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  if (r0 < numDefine1024) {
    r1 = heapClassInst.heap32[fp + numDefine3];
    if (r1 < numDefine97152) {
      if (r1 > -1) {
        r2 = heapClassInst.heap32[fp];
        r3 = heapClassInst.heap32[fp + 1];
        r4 = sp + numDefineNeg32;
        r5 = r4 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg8] = numDefine44395;
        heapClassInst.heap32[r5 + 1] = numDefine44395;
        heapClassInst.heap32[r5 + numDefine2] = numDefine44395;
        r6 = sp + numDefineNeg48;
        heapClassInst.heap32[r5 + numDefine3] = 0;
        r7 = r6 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg12] = numDefineNeg39253;
        heapClassInst.heap32[r7 + 1] = numDefineNeg39253;
        heapClassInst.heap32[r7 + numDefine2] = numDefineNeg39253;
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r7 + numDefine3] = 0;
        f0 = heapClassInst.heapFloat[r3];
        f1 = numDefine49440;
        if (f0 < f1) {
          heapClassInst.heapFloat[fp + numDefineNeg8] = f0;
          f2 = f0;
        } else {
          f2 = f1;
        }
        f3 = heapClassInst.heapFloat[r3 + 1];
        if (f3 < f1) {
          heapClassInst.heapFloat[r5 + 1] = f3;
          f1 = f3;
        } else {
          f1 = numDefine49440;
        }
        f4 = heapClassInst.heapFloat[r3 + numDefine2];
        f5 = numDefine49440;
        if (f4 < f5) {
          heapClassInst.heapFloat[r5 + numDefine2] = f4;
          f5 = f4;
        }
        f6 = heapClassInst.heapFloat[r3 + numDefine3];
        f7 = 0;
        if (f6 < f7) {
          heapClassInst.heapFloat[r5 + numDefine3] = f6;
          f7 = f6;
        }
        f8 = numDefineNeg49440;
        if (f0 > f8) {
          heapClassInst.heapFloat[fp + numDefineNeg12] = f0;
        } else {
          f0 = f8;
        }
        if (f3 > f8) {
          heapClassInst.heapFloat[r7 + 1] = f3;
        } else {
          f3 = numDefineNeg49440;
        }
        f8 = numDefineNeg49440;
        if (f4 > f8) {
          heapClassInst.heapFloat[r7 + numDefine2] = f4;
          f8 = f4;
        }
        f4 = 0;
        if (f6 > f4) {
          heapClassInst.heapFloat[r7 + numDefine3] = f6;
          f4 = f6;
        }
        f6 = heapClassInst.heapFloat[r3 + numDefine4];
        if (f6 < f2) {
          heapClassInst.heapFloat[fp + numDefineNeg8] = f6;
          f2 = f6;
        }
        f9 = heapClassInst.heapFloat[r3 + numDefine5];
        if (f9 < f1) {
          heapClassInst.heapFloat[r5 + 1] = f9;
          f1 = f9;
        }
        f10 = heapClassInst.heapFloat[r3 + numDefine6];
        if (f10 < f5) {
          heapClassInst.heapFloat[r5 + numDefine2] = f10;
          f5 = f10;
        }
        f11 = heapClassInst.heapFloat[r3 + numDefine7];
        if (f11 < f7) {
          heapClassInst.heapFloat[r5 + numDefine3] = f11;
          f7 = f11;
        }
        if (f0 < f6) {
          heapClassInst.heapFloat[fp + numDefineNeg12] = f6;
          f0 = f6;
        }
        if (f3 < f9) {
          heapClassInst.heapFloat[r7 + 1] = f9;
          f3 = f9;
        }
        if (f8 < f10) {
          heapClassInst.heapFloat[r7 + numDefine2] = f10;
          f8 = f10;
        }
        if (f4 < f11) {
          heapClassInst.heapFloat[r7 + numDefine3] = f11;
          f4 = f11;
        }
        f6 = heapClassInst.heapFloat[r3 + numDefine8];
        if (f6 < f2) {
          heapClassInst.heapFloat[fp + numDefineNeg8] = f6;
          f2 = f6;
        }
        f9 = heapClassInst.heapFloat[r3 + numDefine9];
        if (f9 < f1) {
          heapClassInst.heapFloat[r5 + 1] = f9;
          f1 = f9;
        }
        f10 = heapClassInst.heapFloat[r3 + numDefine10];
        if (f10 < f5) {
          heapClassInst.heapFloat[r5 + numDefine2] = f10;
          f5 = f10;
        }
        f11 = heapClassInst.heapFloat[r3 + numDefine11];
        if (!(f11 >= f7)) {
          heapClassInst.heapFloat[r5 + numDefine3] = f11;
        }
        if (f0 < f6) {
          heapClassInst.heapFloat[fp + numDefineNeg12] = f6;
          f0 = f6;
        }
        if (f3 < f9) {
          heapClassInst.heapFloat[r7 + 1] = f9;
          f3 = f9;
        }
        if (f8 < f10) {
          heapClassInst.heapFloat[r7 + numDefine2] = f10;
          f8 = f10;
        }
        if (!(f4 >= f11)) {
          heapClassInst.heapFloat[r7 + numDefine3] = f11;
        }
        f4 = f0 - f2;
        f6 = numDefineFloat026;
        if (!(f4 >= f6)) {
          f4 = numDefineFloat013;
          f0 = f0 + f4;
          f4 = numDefineNegFloat013;
          f2 = f2 + f4;
          heapClassInst.heapFloat[fp + numDefineNeg12] = f0;
          heapClassInst.heapFloat[fp + numDefineNeg8] = f2;
        }
        f0 = f3 - f1;
        if (!(f0 >= f6)) {
          f0 = numDefineFloat013;
          f2 = numDefineNegFloat013;
          f0 = f3 + f0;
          f1 = f1 + f2;
          heapClassInst.heapFloat[r7 + 1] = f0;
          heapClassInst.heapFloat[r5 + 1] = f1;
        }
        f0 = f8 - f5;
        if (!(f0 >= f6)) {
          f0 = numDefineFloat013;
          f1 = numDefineNegFloat013;
          f0 = f8 + f0;
          f1 = f5 + f1;
          heapClassInst.heapFloat[r7 + numDefine2] = f0;
          heapClassInst.heapFloat[r5 + numDefine2] = f1;
        }
        r2 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine2];
        r5 = sp + numDefineNeg16;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r5;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        heapClassInst.heap32[g0 + numDefine3] = 0;
        znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
        r3 = heapClassInst.heap32[r2 + numDefine2];
        r4 = (r5 + numDefine6) | 0;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r6;
        heapClassInst.heap32[g0 + numDefine3] = 1;
        r0 = r0 << numDefine21;
        r0 = r0 | r1;
        znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
        r1 = r5 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine3] = r0;
        r1 = heapClassInst.heap32[r2 + 1];
        r2 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + 1];
        r4 = heapClassInst.heap32[r2 + numDefine2];
        if (r4 === r3) {
          r4 = 1;
          r5 = r3 << 1;
          r3 = r3 === 0 ? r4 : r5;
          heapClassInst.heap32[g0] = r1;
          heapClassInst.heap32[g0 + 1] = r3;
          zn20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi(i7);
          r3 = heapClassInst.heap32[r2 + 1];
        }
        r1 = heapClassInst.heap32[r2 + numDefine3];
        r4 = heapClassInst.heapU16[(sp + numDefineNeg16) >> 1];
        r3 = r3 << numDefine4;
        heapClassInst.heap16[(r1 + r3) >> 1] = r4;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heapU16[(sp + numDefineNeg14) >> 1];
        heapClassInst.heap16[(r1 + numDefine2) >> 1] = r3;
        r3 = heapClassInst.heapU16[(sp + numDefineNeg12) >> 1];
        heapClassInst.heap16[(r1 + numDefine4) >> 1] = r3;
        r3 = heapClassInst.heapU16[(sp + numDefineNeg10) >> 1];
        heapClassInst.heap16[(r1 + numDefine6) >> 1] = r3;
        r3 = heapClassInst.heapU16[(sp + numDefineNeg8) >> 1];
        heapClassInst.heap16[(r1 + numDefine8) >> 1] = r3;
        r3 = heapClassInst.heapU16[(sp + numDefineNeg6) >> 1];
        r4 = r1 >> numDefine2;
        heapClassInst.heap16[(r1 + numDefine10) >> 1] = r3;
        heapClassInst.heap32[r4 + numDefine3] = r0;
        r0 = heapClassInst.heap32[r2 + 1];
        r0 = (r0 + 1) | 0;
        heapClassInst.heap32[r2 + 1] = r0;
        return;
      } else {
        r0 = twoEStr20316;
        r1 = twoEStr10306;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine103;
        assertNew(i7);
      }
    } else {
      r0 = twoEStr19315;
      r1 = twoEStr10306;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine101;
      assertNew(i7);
    }
  } else {
    r0 = twoEStr18314;
    r1 = twoEStr10306;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine100;
    assertNew(i7);
  }
}

function znk14btOptimizedBvh16serializeInPlaceEPvjb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r3;
  znk14btQuantizedBvh9serializeEPvjb(i7);
  r0 = 1;
  commonVariable.rg0 = r0;
  return;
}

function zn14btOptimizedBvhD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv14btOptimizedBvh;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn14btQuantizedBvhD2Ev(i7);
  if (!(r0 === 0)) {
    r0 = gNumAlignedFree;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0];
    r1 = (r1 + 1) | 0;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r2 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}
function zn14btOptimizedBvhD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv14btOptimizedBvh;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn14btQuantizedBvhD2Ev(i7);
  return;
}

function znk23btPolyhedralConvexShape21calculateLocalInertiaEfR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg112;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  r3 = sp + numDefineNeg64;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  r2 = r3 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
  heapClassInst.heap32[r2 + 1] = 0;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine5] = numDefine53216;
  heapClassInst.heap32[r2 + numDefine6] = 0;
  heapClassInst.heap32[r2 + numDefine7] = 0;
  heapClassInst.heap32[r2 + numDefine8] = 0;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine10] = numDefine53216;
  heapClassInst.heap32[r2 + numDefine11] = 0;
  heapClassInst.heap32[r2 + numDefine12] = 0;
  heapClassInst.heap32[r2 + numDefine13] = 0;
  heapClassInst.heap32[r2 + numDefine14] = 0;
  heapClassInst.heap32[r2 + numDefine15] = 0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine2];
  r2 = sp + numDefineNeg80;
  r4 = sp + numDefineNeg96;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r3;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r4;
  functionTable[r1 >> numDefine2](i7);
  r0 = r4 >> numDefine2;
  r1 = r2 >> numDefine2;
  f1 = heapClassInst.heapFloat[r0 + numDefine2];
  f2 = heapClassInst.heapFloat[r1 + numDefine2];
  f3 = heapClassInst.heapFloat[r0 + 1];
  f4 = heapClassInst.heapFloat[r1 + 1];
  f3 = f3 - f4;
  f4 = numDefineFloat05;
  f1 = f1 - f2;
  f2 = heapClassInst.heapFloat[fp + numDefineNeg24];
  f5 = heapClassInst.heapFloat[fp + numDefineNeg20];
  f2 = f2 - f5;
  f3 = f3 * f4;
  f1 = f1 * f4;
  f2 = f2 * f4;
  f3 = f3 + f0;
  f1 = f1 + f0;
  f0 = f2 + f0;
  f2 = f3 + f3;
  f1 = f1 + f1;
  f0 = f0 + f0;
  f2 = f2 * f2;
  f1 = f1 * f1;
  f3 = heapClassInst.heapFloat[fp + 1];
  f4 = numDefineFloat002;
  f0 = f0 * f0;
  r0 = heapClassInst.heap32[fp + numDefine2];
  f5 = f2 + f1;
  f3 = f3 * f4;
  f1 = f0 + f1;
  r0 = r0 >> numDefine2;
  f4 = f5 * f3;
  f0 = f0 + f2;
  f1 = f1 * f3;
  heapClassInst.heapFloat[r0] = f4;
  f0 = f0 * f3;
  heapClassInst.heapFloat[r0 + 1] = f1;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk34btPolyhedralConvexAabbCachingShape7getAabbERK11btTransformR9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  r1 = heapClassInst.heapU8[r0 + numDefine84];
  if (r1 !== 0) {
    r1 = heapClassInst.heap32[fp + 1];
    r2 = heapClassInst.heap32[fp + numDefine2];
    r3 = heapClassInst.heap32[fp + numDefine3];
    r4 = (r0 + numDefine52) | 0;
    r0 = (r0 + numDefine68) | 0;
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heapFloat[g0 + numDefine2] = f0;
    heapClassInst.heap32[g0 + numDefine3] = r1;
    heapClassInst.heap32[g0 + numDefine4] = r2;
    heapClassInst.heap32[g0 + numDefine5] = r3;
    z15btTransformAabbRK9btVector3S1FRK11btTransformRSS5(i7);
    return;
  } else {
    r0 = twoEStr6232;
    r1 = twoEStr7331;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine86;
    assertNew(i7);
  }
}

function zn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg112;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = 1;
  r2 = zgvzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions;
  heapClassInst.heap8[r0 + numDefine84] = r1;
  r3 = heapClassInst.heapU8[r2];
  if (!(r3 !== 0)) {
    r3 = zzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions;
    r3 = r3 >> numDefine2;
    heapClassInst.heap32[r3] = numDefine53216;
    heapClassInst.heap32[r3 + 1] = 0;
    heapClassInst.heap32[r3 + numDefine2] = 0;
    heapClassInst.heap32[r3 + numDefine3] = 0;
    heapClassInst.heap32[r3 + numDefine4] = 0;
    heapClassInst.heap32[r3 + numDefine5] = numDefine53216;
    heapClassInst.heap32[r3 + numDefine6] = 0;
    heapClassInst.heap32[r3 + numDefine7] = 0;
    heapClassInst.heap32[r3 + numDefine8] = 0;
    heapClassInst.heap32[r3 + numDefine9] = 0;
    heapClassInst.heap32[r3 + numDefine10] = numDefine53216;
    heapClassInst.heap32[r3 + numDefine11] = 0;
    heapClassInst.heap32[r3 + numDefine12] = numDefineNeg30432;
    heapClassInst.heap32[r3 + numDefine13] = 0;
    heapClassInst.heap32[r3 + numDefine14] = 0;
    heapClassInst.heap32[r3 + numDefine15] = 0;
    heapClassInst.heap32[r3 + numDefine16] = 0;
    heapClassInst.heap32[r3 + numDefine17] = numDefineNeg30432;
    heapClassInst.heap32[r3 + numDefine18] = 0;
    heapClassInst.heap32[r3 + numDefine19] = 0;
    heapClassInst.heap32[r3 + numDefine20] = 0;
    heapClassInst.heap32[r3 + numDefine21] = 0;
    heapClassInst.heap32[r3 + numDefine22] = numDefineNeg30432;
    heapClassInst.heap32[r3 + numDefine23] = 0;
    heapClassInst.heap8[r2] = r1;
  }
  r1 = sp + numDefineNeg96;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = 0;
  heapClassInst.heap32[g0 + numDefine2] = numDefine96;
  r2 = r0 >> numDefine2;
  memset(i7);
  r3 = heapClassInst.heap32[r2];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine17];
  r4 = zzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = r1;
  heapClassInst.heap32[g0 + numDefine3] = numDefine6;
  functionTable[r3 >> numDefine2](i7);
  f0 = heapClassInst.heapFloat[fp + numDefineNeg24];
  f1 = heapClassInst.heapFloat[r2 + numDefine11];
  f0 = f0 + f1;
  r0 = r1 >> numDefine2;
  heapClassInst.heapFloat[r2 + numDefine17] = f0;
  f0 = heapClassInst.heapFloat[r0 + numDefine12];
  f0 = f0 - f1;
  heapClassInst.heapFloat[r2 + numDefine13] = f0;
  f0 = heapClassInst.heapFloat[r0 + numDefine5];
  f0 = f0 + f1;
  heapClassInst.heapFloat[r2 + numDefine18] = f0;
  f0 = heapClassInst.heapFloat[r0 + numDefine17];
  f0 = f0 - f1;
  heapClassInst.heapFloat[r2 + numDefine14] = f0;
  f0 = heapClassInst.heapFloat[r0 + numDefine10];
  f0 = f0 + f1;
  heapClassInst.heapFloat[r2 + numDefine19] = f0;
  f0 = heapClassInst.heapFloat[r0 + numDefine22];
  f0 = f0 - f1;
  heapClassInst.heapFloat[r2 + numDefine15] = f0;
  return;
}

function znk13btSphereShape37localGetSupportingVertexWithoutMarginERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0] = 0;
  heapClassInst.heap32[r0 + 1] = 0;
  heapClassInst.heap32[r0 + numDefine2] = 0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk13btSphereShape7getNameEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr342;
  commonVariable.rg0 = r0;
  return;
}

function zn13btSphereShape9setMarginEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine11] = heapClassInst.heap32[fp + 1];
  return;
}

function znk13btSphereShape9getMarginEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine7];
  f1 = heapClassInst.heapFloat[r0 + numDefine3];
  f0 = f0 * f1;
  commonVariable.fg0 = f0;
  return;
}

function znk13btSphereShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine3];
  if (!(r0 < 1)) {
    r1 = heapClassInst.heap32[fp + numDefine2];
    r1 = (r1 + numDefine8) | 0;
    repeat3: while (true) {
      r2 = r1 >> numDefine2;
      heapClassInst.heap32[r2 + numDefineNeg2] = 0;
      heapClassInst.heap32[r2 + -1] = 0;
      r0 = (r0 + -1) | 0;
      r1 = (r1 + numDefine16) | 0;
      heapClassInst.heap32[r2] = 0;
      heapClassInst.heap32[r2 + 1] = 0;
      if (r0 !== 0) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function znk13btSphereShape7getAabbERK11btTransformR9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f0 = commonVariable.fg0;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  f1 = commonVariable.fg0;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine11];
  r2 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  r0 = r2 >> numDefine2;
  functionTable[r1 >> numDefine2](i7);
  r1 = heapClassInst.heap32[fp + numDefine2];
  f3 = heapClassInst.heapFloat[r0 + numDefine14];
  f4 = heapClassInst.heapFloat[r0 + numDefine13];
  f5 = heapClassInst.heapFloat[r0 + numDefine12];
  r1 = r1 >> numDefine2;
  f5 = f5 - commonVariable.fg0;
  f4 = f4 - f1;
  heapClassInst.heapFloat[r1] = f5;
  f3 = f3 - f0;
  heapClassInst.heapFloat[r1 + 1] = f4;
  heapClassInst.heapFloat[r1 + numDefine2] = f3;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  r1 = heapClassInst.heap32[fp + numDefine3];
  f3 = heapClassInst.heapFloat[r0 + numDefine14];
  f4 = heapClassInst.heapFloat[r0 + numDefine13];
  f5 = heapClassInst.heapFloat[r0 + numDefine12];
  r0 = r1 >> numDefine2;
  f2 = f5 + commonVariable.fg0;
  f1 = f4 + f1;
  heapClassInst.heapFloat[r0] = f2;
  f0 = f3 + f0;
  heapClassInst.heapFloat[r0 + 1] = f1;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function znk13btSphereShape21calculateLocalInertiaEfR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine11];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine11];
  f1 = heapClassInst.heapFloat[fp + 1];
  f2 = numDefineFloat448;
  f1 = f1 * f2;
  heapClassInst.heap32[g0] = r0;
  r0 = heapClassInst.heap32[fp + numDefine2];
  f0 = f1 * commonVariable.fg0;
  functionTable[r1 >> numDefine2](i7);
  r0 = r0 >> numDefine2;
  f0 = f0 * commonVariable.fg0;
  heapClassInst.heapFloat[r0] = f0;
  heapClassInst.heapFloat[r0 + 1] = f0;
  heapClassInst.heapFloat[r0 + numDefine2] = f0;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  return;
}

function zn13btSphereShapeD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  if (!(r0 === 0)) {
    r0 = gNumAlignedFree;
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0];
    r1 = (r1 + 1) | 0;
    heapClassInst.heap32[r0] = r1;
    r0 = heapClassInst.heap32[r2 + -1];
    heapClassInst.heap32[g0] = r0;
    free(i7);
  }
  return;
}

function zn13btSphereShapeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv13btConvexShape;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function znk13btSphereShape24localGetSupportingVertexERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine16];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = sp + numDefineNeg16;
  heapClassInst.heap32[g0] = r4;
  heapClassInst.heap32[g0 + 1] = r0;
  heapClassInst.heap32[g0 + numDefine2] = r3;
  functionTable[r2 >> numDefine2](i7);
  r2 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[fp];
  f0 = heapClassInst.heapFloat[fp + numDefineNeg4];
  f1 = heapClassInst.heapFloat[r2 + 1];
  f2 = heapClassInst.heapFloat[r2 + numDefine2];
  r4 = r4 >> numDefine2;
  r3 = r3 >> numDefine2;
  heapClassInst.heap32[r4 + numDefine3] = heapClassInst.heap32[r2 + numDefine3];
  f3 = heapClassInst.heapFloat[r3];
  f4 = heapClassInst.heapFloat[r3 + 1];
  f5 = heapClassInst.heapFloat[r3 + numDefine2];
  f6 = f3 * f3;
  f7 = f4 * f4;
  f6 = f6 + f7;
  f7 = f5 * f5;
  f6 = f6 + f7;
  f7 = numDefineFloat4044;
  f8 = -1;
  f3 = f6 < f7 ? f8 : f3;
  f4 = f6 < f7 ? f8 : f4;
  f5 = f6 < f7 ? f8 : f5;
  f6 = f3 * f3;
  f7 = f4 * f4;
  f6 = f6 + f7;
  f7 = f5 * f5;
  f6 = f6 + f7;
  heapClassInst.heapFloat[g0] = f6;
  sqrtf(i7);
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine11];
  f7 = 1;
  f6 = f7 / commonVariable.fg0;
  heapClassInst.heap32[g0] = r0;
  f3 = f3 * f6;
  functionTable[r1 >> numDefine2](i7);
  f4 = f4 * f6;
  f3 = f3 * commonVariable.fg0;
  f5 = f5 * f6;
  f4 = f4 * commonVariable.fg0;
  f0 = f0 + f3;
  f3 = f5 * commonVariable.fg0;
  f1 = f1 + f4;
  heapClassInst.heapFloat[r4] = f0;
  f0 = f2 + f3;
  heapClassInst.heapFloat[r4 + 1] = f1;
  heapClassInst.heapFloat[r4 + numDefine2] = f0;
  return;
}

function znk23btStridingMeshInterface14hasPremadeAabbEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znk23btStridingMeshInterface14setPremadeAabbERK9btVector3S2(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function znk23btStridingMeshInterface14getPremadeAabbEP9btVector3S1(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function znk23btStridingMeshInterface28calculateSerializeBufferSizeEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine28;
  commonVariable.rg0 = r0;
  return;
}

function znk23btStridingMeshInterface9serializeEPvP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg72;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine7];
  r3 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r3 = r3 >> numDefine2;
  heapClassInst.heap32[r3 + numDefine5] = r2;
  heapClassInst.heap32[r3] = 0;
  if (!(r2 === 0)) {
    r4 = heapClassInst.heap32[fp + numDefine2];
    r5 = r4 >> numDefine2;
    r6 = heapClassInst.heap32[r5];
    r6 = r6 >> numDefine2;
    r6 = heapClassInst.heap32[r6 + numDefine4];
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = numDefine28;
    heapClassInst.heap32[g0 + numDefine2] = r2;
    functionTable[r6 >> numDefine2](i7);
    r2 = commonVariable.rg0;
    r6 = heapClassInst.heap32[r5];
    r6 = r6 >> numDefine2;
    r7 = r2 >> numDefine2;
    r7 = heapClassInst.heap32[r7 + numDefine2];
    r6 = heapClassInst.heap32[r6 + numDefine7];
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r7;
    functionTable[r6 >> numDefine2](i7);
    heapClassInst.heap32[r3] = commonVariable.rg0;
    r6 = heapClassInst.heap32[r1];
    r6 = r6 >> numDefine2;
    r6 = heapClassInst.heap32[r6 + numDefine7];
    heapClassInst.heap32[g0] = r0;
    r8 = 0;
    functionTable[r6 >> numDefine2](i7);
    r6 = commonVariable.rg0;
    repeat3: while (true) {
      if (r8 < r6) {
        r9 = heapClassInst.heap32[r1];
        r9 = r9 >> numDefine2;
        r9 = heapClassInst.heap32[r9 + numDefine4];
        r10 = sp + numDefineNeg4;
        r11 = sp + numDefineNeg28;
        r12 = sp + numDefineNeg16;
        r13 = sp + numDefineNeg24;
        r14 = sp + numDefineNeg8;
        r15 = sp + numDefineNeg12;
        r16 = sp + numDefineNeg32;
        r17 = sp + numDefineNeg20;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r10;
        heapClassInst.heap32[g0 + numDefine2] = r11;
        heapClassInst.heap32[g0 + numDefine3] = r12;
        heapClassInst.heap32[g0 + numDefine4] = r13;
        heapClassInst.heap32[g0 + numDefine5] = r14;
        heapClassInst.heap32[g0 + numDefine6] = r15;
        heapClassInst.heap32[g0 + numDefine7] = r16;
        heapClassInst.heap32[g0 + numDefine8] = r17;
        heapClassInst.heap32[g0 + numDefine9] = r8;
        functionTable[r9 >> numDefine2](i7);
        r9 = r7 >> numDefine2;
        r10 = heapClassInst.heap32[fp + numDefineNeg8];
        heapClassInst.heap32[r9 + numDefine5] = r10;
        r10 = heapClassInst.heap32[fp + numDefineNeg7];
        heapClassInst.heap32[r9 + numDefine6] = r10;
        heapClassInst.heap32[r9 + numDefine4] = 0;
        heapClassInst.heap32[r9 + numDefine2] = 0;
        heapClassInst.heap32[r9 + numDefine3] = 0;
        heapClassInst.heap32[r9] = 0;
        heapClassInst.heap32[r9 + 1] = 0;
        r10 = heapClassInst.heap32[fp + numDefineNeg5];
        if (r10 === numDefine3) {
          r10 = heapClassInst.heap32[fp + numDefineNeg8];
          if (!(r10 === 0)) {
            r11 = heapClassInst.heap32[r5];
            r11 = r11 >> numDefine2;
            r11 = heapClassInst.heap32[r11 + numDefine4];
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = numDefine8;
            heapClassInst.heap32[g0 + numDefine2] = r10;
            functionTable[r11 >> numDefine2](i7);
            r10 = commonVariable.rg0;
            r11 = heapClassInst.heap32[r5];
            r11 = r11 >> numDefine2;
            r12 = r10 >> numDefine2;
            r12 = heapClassInst.heap32[r12 + numDefine2];
            r11 = heapClassInst.heap32[r11 + numDefine7];
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r12;
            functionTable[r11 >> numDefine2](i7);
            heapClassInst.heap32[r9 + numDefine3] = commonVariable.rg0;
            r11 = heapClassInst.heap32[fp + numDefineNeg8];
            if (!(r11 < 1)) {
              r11 = 0;
              repeat11: while (true) {
                r13 = heapClassInst.heap32[fp + numDefineNeg3];
                r13 = (r13 * r11) | 0;
                r14 = heapClassInst.heap32[fp + numDefineNeg2];
                r15 = heapClassInst.heapU16[(r14 + r13) >> 1];
                r16 = r11 << numDefine3;
                r13 = (r14 + r13) | 0;
                heapClassInst.heap16[(r12 + r16) >> 1] = r15;
                r14 = (r12 + r16) | 0;
                r15 = heapClassInst.heapU16[(r13 + numDefine2) >> 1];
                heapClassInst.heap16[(r14 + numDefine2) >> 1] = r15;
                r13 = heapClassInst.heapU16[(r13 + numDefine4) >> 1];
                r11 = (r11 + 1) | 0;
                heapClassInst.heap16[(r14 + numDefine4) >> 1] = r13;
                r13 = heapClassInst.heap32[fp + numDefineNeg8];
                if (!(r11 < r13)) {
                  break repeat11;
                }
              }
            }
            r11 = heapClassInst.heap32[r5];
            r11 = r11 >> numDefine2;
            r12 = r10 >> numDefine2;
            r11 = heapClassInst.heap32[r11 + numDefine5];
            r12 = heapClassInst.heap32[r12 + numDefine2];
            r13 = twoEStr1350;
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r10;
            heapClassInst.heap32[g0 + numDefine2] = r13;
            heapClassInst.heap32[g0 + numDefine3] = numDefine53121;
            heapClassInst.heap32[g0 + numDefine4] = r12;
            functionTable[r11 >> numDefine2](i7);
          }
        } else {
          if (r10 !== numDefine2) {
            label = numDefine14;
            break repeat3;
          } else {
            r10 = heapClassInst.heap32[fp + numDefineNeg8];
            r10 = (r10 * numDefine3) | 0;
            if (!(r10 === 0)) {
              r11 = heapClassInst.heap32[r5];
              r11 = r11 >> numDefine2;
              r11 = heapClassInst.heap32[r11 + numDefine4];
              heapClassInst.heap32[g0] = r4;
              heapClassInst.heap32[g0 + 1] = numDefine4;
              heapClassInst.heap32[g0 + numDefine2] = r10;
              functionTable[r11 >> numDefine2](i7);
              r10 = commonVariable.rg0;
              r11 = heapClassInst.heap32[r5];
              r11 = r11 >> numDefine2;
              r12 = r10 >> numDefine2;
              r12 = heapClassInst.heap32[r12 + numDefine2];
              r11 = heapClassInst.heap32[r11 + numDefine7];
              heapClassInst.heap32[g0] = r4;
              heapClassInst.heap32[g0 + 1] = r12;
              functionTable[r11 >> numDefine2](i7);
              heapClassInst.heap32[r9 + numDefine2] = commonVariable.rg0;
              r11 = heapClassInst.heap32[fp + numDefineNeg8];
              repeat17: do {
                if (!(r11 < 1)) {
                  r11 = 0;
                  while (true) {
                    r13 = heapClassInst.heap32[fp + numDefineNeg3];
                    r13 = (r13 * r11) | 0;
                    r14 = heapClassInst.heap32[fp + numDefineNeg2];
                    r15 = (r11 * numDefine3) | 0;
                    r13 = (r14 + r13) | 0;
                    r13 = r13 >> numDefine2;
                    r14 = r15 << numDefine2;
                    r14 = (r12 + r14) | 0;
                    r15 = heapClassInst.heap32[r13];
                    r14 = r14 >> numDefine2;
                    heapClassInst.heap32[r14] = r15;
                    r15 = heapClassInst.heap32[r13 + 1];
                    heapClassInst.heap32[r14 + 1] = r15;
                    r13 = heapClassInst.heap32[r13 + numDefine2];
                    r11 = (r11 + 1) | 0;
                    heapClassInst.heap32[r14 + numDefine2] = r13;
                    r13 = heapClassInst.heap32[fp + numDefineNeg8];
                    if (!(r11 < r13)) {
                      break repeat17;
                    }
                  }
                }
              } while (false);
              r11 = heapClassInst.heap32[r5];
              r11 = r11 >> numDefine2;
              r12 = r10 >> numDefine2;
              r11 = heapClassInst.heap32[r11 + numDefine5];
              r12 = heapClassInst.heap32[r12 + numDefine2];
              r13 = twoEStr349;
              heapClassInst.heap32[g0] = r4;
              heapClassInst.heap32[g0 + 1] = r10;
              heapClassInst.heap32[g0 + numDefine2] = r13;
              heapClassInst.heap32[g0 + numDefine3] = numDefine53121;
              heapClassInst.heap32[g0 + numDefine4] = r12;
              functionTable[r11 >> numDefine2](i7);
            }
          }
        }
        r10 = heapClassInst.heap32[fp + numDefineNeg4];
        repeat23: do {
          if (r10 === 1) {
            r10 = heapClassInst.heap32[fp + numDefineNeg7];
            if (r10 === 0) {
              break repeat23;
            } else {
              r11 = heapClassInst.heap32[r5];
              r11 = r11 >> numDefine2;
              r11 = heapClassInst.heap32[r11 + numDefine4];
              heapClassInst.heap32[g0] = r4;
              heapClassInst.heap32[g0 + 1] = numDefine32;
              heapClassInst.heap32[g0 + numDefine2] = r10;
              functionTable[r11 >> numDefine2](i7);
              r10 = commonVariable.rg0;
              r11 = heapClassInst.heap32[r5];
              r11 = r11 >> numDefine2;
              r12 = r10 >> numDefine2;
              r12 = heapClassInst.heap32[r12 + numDefine2];
              r11 = heapClassInst.heap32[r11 + numDefine7];
              heapClassInst.heap32[g0] = r4;
              heapClassInst.heap32[g0 + 1] = r12;
              functionTable[r11 >> numDefine2](i7);
              heapClassInst.heap32[r9 + 1] = commonVariable.rg0;
              r9 = heapClassInst.heap32[fp + numDefineNeg7];
              repeat26: do {
                if (!(r9 < 1)) {
                  r11 = heapClassInst.heap32[fp + -1];
                  r13 = heapClassInst.heap32[fp + numDefineNeg6];
                  r11 = (r11 + numDefine16) | 0;
                  r14 = 0;
                  while (true) {
                    r15 = r14 << numDefine5;
                    r15 = (r12 + r15) | 0;
                    llvmMoveDouble(r15, r11 + numDefineNeg16);
                    r14 = (r14 + 1) | 0;
                    r16 = (r11 + r13) | 0;
                    llvmMoveDouble(r15 + numDefine8, r11 + numDefineNeg8);
                    llvmMoveDouble(r15 + numDefine16, r11);
                    r11 = r16;
                    if (!(r14 < r9)) {
                      break repeat26;
                    }
                  }
                }
              } while (false);
              r9 = heapClassInst.heap32[r5];
              r9 = r9 >> numDefine2;
              r11 = r10 >> numDefine2;
              r9 = heapClassInst.heap32[r9 + numDefine5];
              r11 = heapClassInst.heap32[r11 + numDefine2];
              r12 = twoEStr5354;
              heapClassInst.heap32[g0] = r4;
              heapClassInst.heap32[g0 + 1] = r10;
              heapClassInst.heap32[g0 + numDefine2] = r12;
              heapClassInst.heap32[g0 + numDefine3] = numDefine53121;
              heapClassInst.heap32[g0 + numDefine4] = r11;
              functionTable[r9 >> numDefine2](i7);
            }
          } else {
            if (r10 !== 0) {
              if (!(uint(r10) < uint(numDefine2))) {
                label = numDefine28;
                break repeat3;
              }
            } else {
              r10 = heapClassInst.heap32[fp + numDefineNeg7];
              if (!(r10 === 0)) {
                r11 = heapClassInst.heap32[r5];
                r11 = r11 >> numDefine2;
                r11 = heapClassInst.heap32[r11 + numDefine4];
                heapClassInst.heap32[g0] = r4;
                heapClassInst.heap32[g0 + 1] = numDefine16;
                heapClassInst.heap32[g0 + numDefine2] = r10;
                functionTable[r11 >> numDefine2](i7);
                r10 = commonVariable.rg0;
                r11 = heapClassInst.heap32[r5];
                r11 = r11 >> numDefine2;
                r12 = r10 >> numDefine2;
                r12 = heapClassInst.heap32[r12 + numDefine2];
                r11 = heapClassInst.heap32[r11 + numDefine7];
                heapClassInst.heap32[g0] = r4;
                heapClassInst.heap32[g0 + 1] = r12;
                functionTable[r11 >> numDefine2](i7);
                heapClassInst.heap32[r9] = commonVariable.rg0;
                r9 = heapClassInst.heap32[fp + numDefineNeg7];
                repeat36: do {
                  if (!(r9 < 1)) {
                    r9 = 0;
                    while (true) {
                      r11 = heapClassInst.heap32[fp + numDefineNeg6];
                      r13 = heapClassInst.heap32[fp + -1];
                      r11 = (r11 * r9) | 0;
                      r14 = r9 << numDefine4;
                      r14 = (r12 + r14) | 0;
                      r11 = (r13 + r11) | 0;
                      r13 = r14 >> numDefine2;
                      r11 = r11 >> numDefine2;
                      heapClassInst.heap32[r13] = heapClassInst.heap32[r11];
                      r9 = (r9 + 1) | 0;
                      heapClassInst.heap32[r13 + 1] = heapClassInst.heap32[r11 + 1];
                      heapClassInst.heap32[r13 + numDefine2] = heapClassInst.heap32[r11 + numDefine2];
                      r11 = heapClassInst.heap32[fp + numDefineNeg7];
                      if (!(r9 < r11)) {
                        break repeat36;
                      }
                    }
                  }
                } while (false);
                r9 = heapClassInst.heap32[r5];
                r9 = r9 >> numDefine2;
                r11 = r10 >> numDefine2;
                r9 = heapClassInst.heap32[r9 + numDefine5];
                r11 = heapClassInst.heap32[r11 + numDefine2];
                r12 = twoEStr5223;
                heapClassInst.heap32[g0] = r4;
                heapClassInst.heap32[g0 + 1] = r10;
                heapClassInst.heap32[g0 + numDefine2] = r12;
                heapClassInst.heap32[g0 + numDefine3] = numDefine53121;
                heapClassInst.heap32[g0 + numDefine4] = r11;
                functionTable[r9 >> numDefine2](i7);
              }
            }
          }
        } while (false);
        r9 = heapClassInst.heap32[r1];
        r9 = r9 >> numDefine2;
        r9 = heapClassInst.heap32[r9 + numDefine6];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r8;
        r8 = (r8 + 1) | 0;
        r7 = (r7 + numDefine28) | 0;
        functionTable[r9 >> numDefine2](i7);
      } else {
        label = numDefine31;
        break repeat3;
      }
    }
    switch (label) {
      case numDefine31:
        r0 = heapClassInst.heap32[r5];
        r0 = r0 >> numDefine2;
        r5 = r2 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine5];
        r5 = heapClassInst.heap32[r5 + numDefine2];
        r6 = twoEStr7356;
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r6;
        heapClassInst.heap32[g0 + numDefine3] = numDefine53121;
        heapClassInst.heap32[g0 + numDefine4] = r5;
        functionTable[r0 >> numDefine2](i7);
        break;
      case numDefine28:
        r0 = twoEStr6355;
        r1 = twoEStr3352;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine319;
        assertNew(i7);
        break;
      case numDefine14:
        r0 = twoEStr10;
        r1 = twoEStr3352;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine271;
        assertNew(i7);
        break;
      default:
        break;
    }
  }
  heapClassInst.heap32[r3 + 1] = heapClassInst.heap32[r1 + 1];
  heapClassInst.heap32[r3 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
  heapClassInst.heap32[r3 + numDefine3] = heapClassInst.heap32[r1 + numDefine3];
  heapClassInst.heap32[r3 + numDefine4] = heapClassInst.heap32[r1 + numDefine4];
  r0 = twoEStr8357;
  commonVariable.rg0 = r0;
  return;
}

function znk23btStridingMeshInterface27InternalProcessAllTrianglesEP31btInternalTriangleIndexCallbackRK9btVector3S4(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg120;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine7];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  r3 = heapClassInst.heap32[fp + 1];
  f0 = heapClassInst.heapFloat[r1 + 1];
  f1 = heapClassInst.heapFloat[r1 + numDefine2];
  f2 = heapClassInst.heapFloat[r1 + numDefine3];
  r4 = 0;
  repeat1: while (true) {
    if (r4 < r2) {
      r5 = heapClassInst.heap32[r1];
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5 + numDefine4];
      r6 = sp + numDefineNeg4;
      r7 = sp + numDefineNeg28;
      r8 = sp + numDefineNeg16;
      r9 = sp + numDefineNeg24;
      r10 = sp + numDefineNeg8;
      r11 = sp + numDefineNeg12;
      r12 = sp + numDefineNeg32;
      r13 = sp + numDefineNeg20;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r6;
      heapClassInst.heap32[g0 + numDefine2] = r7;
      heapClassInst.heap32[g0 + numDefine3] = r8;
      heapClassInst.heap32[g0 + numDefine4] = r9;
      heapClassInst.heap32[g0 + numDefine5] = r10;
      heapClassInst.heap32[g0 + numDefine6] = r11;
      heapClassInst.heap32[g0 + numDefine7] = r12;
      heapClassInst.heap32[g0 + numDefine8] = r13;
      heapClassInst.heap32[g0 + numDefine9] = r4;
      functionTable[r5 >> numDefine2](i7);
      r5 = heapClassInst.heap32[fp + numDefineNeg4];
      repeat4: do {
        if (r5 === 1) {
          r5 = heapClassInst.heap32[fp + numDefineNeg5];
          if (r5 === numDefine3) {
            r5 = heapClassInst.heap32[fp + numDefineNeg8];
            if (r5 < 1) {
              break repeat4;
            } else {
              r5 = 0;
              repeat9: while (true) {
                r6 = heapClassInst.heap32[fp + numDefineNeg3];
                r7 = heapClassInst.heap32[fp + numDefineNeg2];
                r6 = (r6 * r5) | 0;
                r8 = heapClassInst.heapU16[(r7 + r6) >> 1];
                r9 = heapClassInst.heap32[fp + numDefineNeg6];
                r10 = heapClassInst.heap32[fp + -1];
                r8 = (r8 * r9) | 0;
                r11 = (r10 + r8) | 0;
                f3 = llvmReadDouble(r10 + r8);
                f4 = llvmReadDouble(r11 + numDefine16);
                f5 = llvmReadDouble(r11 + numDefine8);
                f3 = f3;
                r8 = sp + numDefineNeg80;
                f5 = f5;
                f3 = f3 * f0;
                r11 = r8 >> numDefine2;
                f4 = f4;
                f5 = f5 * f1;
                heapClassInst.heapFloat[fp + numDefineNeg20] = f3;
                f3 = f4 * f2;
                heapClassInst.heapFloat[r11 + 1] = f5;
                heapClassInst.heapFloat[r11 + numDefine2] = f3;
                r6 = (r7 + r6) | 0;
                heapClassInst.heap32[r11 + numDefine3] = 0;
                r7 = heapClassInst.heapU16[(r6 + numDefine2) >> 1];
                r7 = (r7 * r9) | 0;
                r12 = (r10 + r7) | 0;
                f3 = llvmReadDouble(r10 + r7);
                f3 = f3;
                f4 = llvmReadDouble(r12 + numDefine16);
                f5 = llvmReadDouble(r12 + numDefine8);
                f5 = f5;
                f3 = f3 * f0;
                f4 = f4;
                f5 = f5 * f1;
                heapClassInst.heapFloat[r11 + numDefine4] = f3;
                f3 = f4 * f2;
                heapClassInst.heapFloat[r11 + numDefine5] = f5;
                heapClassInst.heapFloat[r11 + numDefine6] = f3;
                heapClassInst.heap32[r11 + numDefine7] = 0;
                r6 = heapClassInst.heapU16[(r6 + numDefine4) >> 1];
                r6 = (r6 * r9) | 0;
                r7 = (r10 + r6) | 0;
                f3 = llvmReadDouble(r10 + r6);
                f3 = f3;
                f4 = llvmReadDouble(r7 + numDefine16);
                f5 = llvmReadDouble(r7 + numDefine8);
                f5 = f5;
                f3 = f3 * f0;
                f4 = f4;
                f5 = f5 * f1;
                heapClassInst.heapFloat[r11 + numDefine8] = f3;
                f3 = f4 * f2;
                heapClassInst.heapFloat[r11 + numDefine9] = f5;
                heapClassInst.heapFloat[r11 + numDefine10] = f3;
                r6 = r3 >> numDefine2;
                heapClassInst.heap32[r11 + numDefine11] = 0;
                r6 = heapClassInst.heap32[r6];
                r6 = r6 >> numDefine2;
                r6 = heapClassInst.heap32[r6 + numDefine2];
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r8;
                heapClassInst.heap32[g0 + numDefine2] = r4;
                heapClassInst.heap32[g0 + numDefine3] = r5;
                r5 = (r5 + 1) | 0;
                functionTable[r6 >> numDefine2](i7);
                r6 = heapClassInst.heap32[fp + numDefineNeg8];
                if (r5 < r6) {
                  continue repeat9;
                } else {
                  break repeat4;
                }
              }
            }
          } else {
            if (r5 !== numDefine2) {
              r5 = (r5 + numDefineNeg2) | 0;
              if (!(uint(r5) < uint(numDefine2))) {
                label = numDefine22;
                break repeat1;
              }
            } else {
              r5 = heapClassInst.heap32[fp + numDefineNeg8];
              if (r5 < 1) {
                break repeat4;
              } else {
                r5 = 0;
                repeat16: while (true) {
                  r6 = heapClassInst.heap32[fp + numDefineNeg3];
                  r7 = heapClassInst.heap32[fp + numDefineNeg2];
                  r6 = (r6 * r5) | 0;
                  r6 = (r7 + r6) | 0;
                  r6 = r6 >> numDefine2;
                  r7 = heapClassInst.heap32[r6];
                  r8 = heapClassInst.heap32[fp + numDefineNeg6];
                  r9 = heapClassInst.heap32[fp + -1];
                  r7 = (r8 * r7) | 0;
                  r10 = (r9 + r7) | 0;
                  f3 = llvmReadDouble(r9 + r7);
                  f4 = llvmReadDouble(r10 + numDefine16);
                  f5 = llvmReadDouble(r10 + numDefine8);
                  f3 = f3;
                  r7 = sp + numDefineNeg80;
                  f5 = f5;
                  f3 = f3 * f0;
                  r10 = r7 >> numDefine2;
                  f4 = f4;
                  f5 = f5 * f1;
                  heapClassInst.heapFloat[fp + numDefineNeg20] = f3;
                  f3 = f4 * f2;
                  heapClassInst.heapFloat[r10 + 1] = f5;
                  heapClassInst.heapFloat[r10 + numDefine2] = f3;
                  heapClassInst.heap32[r10 + numDefine3] = 0;
                  r11 = heapClassInst.heap32[r6 + 1];
                  r11 = (r8 * r11) | 0;
                  r12 = (r9 + r11) | 0;
                  f3 = llvmReadDouble(r9 + r11);
                  f3 = f3;
                  f4 = llvmReadDouble(r12 + numDefine16);
                  f5 = llvmReadDouble(r12 + numDefine8);
                  f5 = f5;
                  f3 = f3 * f0;
                  f4 = f4;
                  f5 = f5 * f1;
                  heapClassInst.heapFloat[r10 + numDefine4] = f3;
                  f3 = f4 * f2;
                  heapClassInst.heapFloat[r10 + numDefine5] = f5;
                  heapClassInst.heapFloat[r10 + numDefine6] = f3;
                  heapClassInst.heap32[r10 + numDefine7] = 0;
                  r6 = heapClassInst.heap32[r6 + numDefine2];
                  r6 = (r8 * r6) | 0;
                  r8 = (r9 + r6) | 0;
                  f3 = llvmReadDouble(r9 + r6);
                  f3 = f3;
                  f4 = llvmReadDouble(r8 + numDefine16);
                  f5 = llvmReadDouble(r8 + numDefine8);
                  f5 = f5;
                  f3 = f3 * f0;
                  f4 = f4;
                  f5 = f5 * f1;
                  heapClassInst.heapFloat[r10 + numDefine8] = f3;
                  f3 = f4 * f2;
                  heapClassInst.heapFloat[r10 + numDefine9] = f5;
                  heapClassInst.heapFloat[r10 + numDefine10] = f3;
                  r6 = r3 >> numDefine2;
                  heapClassInst.heap32[r10 + numDefine11] = 0;
                  r6 = heapClassInst.heap32[r6];
                  r6 = r6 >> numDefine2;
                  r6 = heapClassInst.heap32[r6 + numDefine2];
                  heapClassInst.heap32[g0] = r3;
                  heapClassInst.heap32[g0 + 1] = r7;
                  heapClassInst.heap32[g0 + numDefine2] = r4;
                  heapClassInst.heap32[g0 + numDefine3] = r5;
                  r5 = (r5 + 1) | 0;
                  functionTable[r6 >> numDefine2](i7);
                  r6 = heapClassInst.heap32[fp + numDefineNeg8];
                  if (r5 < r6) {
                    continue repeat16;
                  } else {
                    break repeat4;
                  }
                }
              }
            }
          }
        } else {
          if (r5 !== 0) {
            if (!(uint(r5) < uint(numDefine2))) {
              label = numDefine24;
              break repeat1;
            }
          } else {
            r5 = heapClassInst.heap32[fp + numDefineNeg5];
            if (r5 === numDefine3) {
              r5 = heapClassInst.heap32[fp + numDefineNeg8];
              if (r5 < 1) {
                break repeat4;
              } else {
                r5 = 0;
                repeat25: while (true) {
                  r6 = heapClassInst.heap32[fp + numDefineNeg3];
                  r7 = heapClassInst.heap32[fp + numDefineNeg2];
                  r6 = (r6 * r5) | 0;
                  r8 = heapClassInst.heapU16[(r7 + r6) >> 1];
                  r9 = heapClassInst.heap32[fp + numDefineNeg6];
                  r10 = heapClassInst.heap32[fp + -1];
                  r8 = (r8 * r9) | 0;
                  r8 = (r10 + r8) | 0;
                  r8 = r8 >> numDefine2;
                  f3 = heapClassInst.heapFloat[r8];
                  f4 = heapClassInst.heapFloat[r8 + numDefine2];
                  f5 = heapClassInst.heapFloat[r8 + 1];
                  r8 = sp + numDefineNeg80;
                  f3 = f3 * f0;
                  r11 = r8 >> numDefine2;
                  f5 = f5 * f1;
                  heapClassInst.heapFloat[fp + numDefineNeg20] = f3;
                  f3 = f4 * f2;
                  heapClassInst.heapFloat[r11 + 1] = f5;
                  heapClassInst.heapFloat[r11 + numDefine2] = f3;
                  r6 = (r7 + r6) | 0;
                  heapClassInst.heap32[r11 + numDefine3] = 0;
                  r7 = heapClassInst.heapU16[(r6 + numDefine2) >> 1];
                  r7 = (r7 * r9) | 0;
                  r7 = (r10 + r7) | 0;
                  r7 = r7 >> numDefine2;
                  f3 = heapClassInst.heapFloat[r7 + numDefine2];
                  f4 = heapClassInst.heapFloat[r7 + 1];
                  f5 = heapClassInst.heapFloat[r7];
                  f5 = f5 * f0;
                  f4 = f4 * f1;
                  heapClassInst.heapFloat[r11 + numDefine4] = f5;
                  f3 = f3 * f2;
                  heapClassInst.heapFloat[r11 + numDefine5] = f4;
                  heapClassInst.heapFloat[r11 + numDefine6] = f3;
                  heapClassInst.heap32[r11 + numDefine7] = 0;
                  r6 = heapClassInst.heapU16[(r6 + numDefine4) >> 1];
                  r6 = (r6 * r9) | 0;
                  r6 = (r10 + r6) | 0;
                  r6 = r6 >> numDefine2;
                  f3 = heapClassInst.heapFloat[r6 + numDefine2];
                  f4 = heapClassInst.heapFloat[r6 + 1];
                  f5 = heapClassInst.heapFloat[r6];
                  f5 = f5 * f0;
                  f4 = f4 * f1;
                  heapClassInst.heapFloat[r11 + numDefine8] = f5;
                  f3 = f3 * f2;
                  heapClassInst.heapFloat[r11 + numDefine9] = f4;
                  heapClassInst.heapFloat[r11 + numDefine10] = f3;
                  r6 = r3 >> numDefine2;
                  heapClassInst.heap32[r11 + numDefine11] = 0;
                  r6 = heapClassInst.heap32[r6];
                  r6 = r6 >> numDefine2;
                  r6 = heapClassInst.heap32[r6 + numDefine2];
                  heapClassInst.heap32[g0] = r3;
                  heapClassInst.heap32[g0 + 1] = r8;
                  heapClassInst.heap32[g0 + numDefine2] = r4;
                  heapClassInst.heap32[g0 + numDefine3] = r5;
                  r5 = (r5 + 1) | 0;
                  functionTable[r6 >> numDefine2](i7);
                  r6 = heapClassInst.heap32[fp + numDefineNeg8];
                  if (r5 < r6) {
                    continue repeat25;
                  } else {
                    break repeat4;
                  }
                }
              }
            } else {
              if (r5 !== numDefine2) {
                r5 = (r5 + numDefineNeg2) | 0;
                if (!(uint(r5) < uint(numDefine2))) {
                  label = numDefine12;
                  break repeat1;
                }
              } else {
                r5 = heapClassInst.heap32[fp + numDefineNeg8];
                if (!(r5 < 1)) {
                  r5 = 0;
                  while (true) {
                    r6 = heapClassInst.heap32[fp + numDefineNeg3];
                    r7 = heapClassInst.heap32[fp + numDefineNeg2];
                    r6 = (r6 * r5) | 0;
                    r6 = (r7 + r6) | 0;
                    r6 = r6 >> numDefine2;
                    r7 = heapClassInst.heap32[r6];
                    r8 = heapClassInst.heap32[fp + numDefineNeg6];
                    r9 = heapClassInst.heap32[fp + -1];
                    r7 = (r8 * r7) | 0;
                    r7 = (r9 + r7) | 0;
                    r7 = r7 >> numDefine2;
                    f3 = heapClassInst.heapFloat[r7];
                    f4 = heapClassInst.heapFloat[r7 + numDefine2];
                    f5 = heapClassInst.heapFloat[r7 + 1];
                    r7 = sp + numDefineNeg80;
                    f3 = f3 * f0;
                    r10 = r7 >> numDefine2;
                    f5 = f5 * f1;
                    heapClassInst.heapFloat[fp + numDefineNeg20] = f3;
                    f3 = f4 * f2;
                    heapClassInst.heapFloat[r10 + 1] = f5;
                    heapClassInst.heapFloat[r10 + numDefine2] = f3;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    r11 = heapClassInst.heap32[r6 + 1];
                    r11 = (r8 * r11) | 0;
                    r11 = (r9 + r11) | 0;
                    r11 = r11 >> numDefine2;
                    f3 = heapClassInst.heapFloat[r11 + numDefine2];
                    f4 = heapClassInst.heapFloat[r11 + 1];
                    f5 = heapClassInst.heapFloat[r11];
                    f5 = f5 * f0;
                    f4 = f4 * f1;
                    heapClassInst.heapFloat[r10 + numDefine4] = f5;
                    f3 = f3 * f2;
                    heapClassInst.heapFloat[r10 + numDefine5] = f4;
                    heapClassInst.heapFloat[r10 + numDefine6] = f3;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    r6 = heapClassInst.heap32[r6 + numDefine2];
                    r6 = (r8 * r6) | 0;
                    r6 = (r9 + r6) | 0;
                    r6 = r6 >> numDefine2;
                    f3 = heapClassInst.heapFloat[r6 + numDefine2];
                    f4 = heapClassInst.heapFloat[r6 + 1];
                    f5 = heapClassInst.heapFloat[r6];
                    f5 = f5 * f0;
                    f4 = f4 * f1;
                    heapClassInst.heapFloat[r10 + numDefine8] = f5;
                    f3 = f3 * f2;
                    heapClassInst.heapFloat[r10 + numDefine9] = f4;
                    heapClassInst.heapFloat[r10 + numDefine10] = f3;
                    r6 = r3 >> numDefine2;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    r6 = heapClassInst.heap32[r6];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine2];
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heap32[g0 + 1] = r7;
                    heapClassInst.heap32[g0 + numDefine2] = r4;
                    heapClassInst.heap32[g0 + numDefine3] = r5;
                    r5 = (r5 + 1) | 0;
                    functionTable[r6 >> numDefine2](i7);
                    r6 = heapClassInst.heap32[fp + numDefineNeg8];
                    if (!(r5 < r6)) {
                      break repeat4;
                    }
                  }
                }
              }
            }
          }
        }
      } while (false);
      r5 = heapClassInst.heap32[r1];
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5 + numDefine6];
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r4;
      r4 = (r4 + 1) | 0;
      functionTable[r5 >> numDefine2](i7);
      continue repeat1;
    } else {
      label = numDefine27;
      break repeat1;
    }
  }
  switch (label) {
    case numDefine27:
      return;
    case numDefine22:
      r0 = twoEStr9358;
      r1 = twoEStr3352;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine134;
      assertNew(i7);
      break;
    case numDefine24:
      r0 = twoEStr6355;
      r1 = twoEStr3352;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine139;
      assertNew(i7);
      break;
    case numDefine12:
      r0 = twoEStr9358;
      r1 = twoEStr3352;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine92;
      assertNew(i7);
      break;
    default:
      break;
  }
}

export { zn28btCompoundCollisionAlgorithmD0Ev, zn28btCompoundCollisionAlgorithmD1Ev };

export { znk21btConvexInternalShape15getLocalScalingEv, zn21btConvexInternalShape9setMarginEf };

export { znk21btConvexInternalShape9getMarginEv, znk21btConvexInternalShape28calculateSerializeBufferSizeEv };

export { znk15btTriangleShape14getNumVerticesEv, znk15btTriangleShape9getVertexEiR9btVector3 };

export { znk15btTriangleShape11getNumEdgesEv, znk15btTriangleShape7getEdgeEiR9btVector3S1 };

export { znk15btTriangleShape7getAabbERK11btTransformR9btVector3S4 };

export { znk15btTriangleShape37localGetSupportingVertexWithoutMarginERK9btVector3 };

export { znk15btTriangleShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I };

export { znk15btTriangleShape8getPlaneER9btVector3S1I, znk15btTriangleShape12getNumPlanesEv };

export { znk15btTriangleShape7getNameEv, znk15btTriangleShape36getNumPreferredPenetrationDirectionsEv };

export { zn24btConvexTriangleCallbackD1Ev, zn24btConvexTriangleCallbackD0Ev };

export { zn24btConvexTriangleCallback15processTriangleEP9btVector3ii };

export { zn33btCollisionAlgorithm };

export { zn33btConcaveCollision };

export { zn30btConvexConcave };

export { zn15btTriangleShapeD1Ev, zn15btTriangleShapeD0Ev, znk15btTriangleShape21calculateLocalInertiaEfR9btVector3 };

export { znk21btConvexInternalShape9serializeEPvP12btSerializer };

export { znk15btTriangleShape32getPreferredPenetrationDirectionEiR9btVector3 };

export { znk15btTriangleShape8isInsideERK9btVector3f, znk15btTriangleShape16getPlaneEquationEiR9btVector3S1 };

export { zn33btConvexConcaveCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn33btConvexConcaveCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn33btConvexConcaveCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE };

export { zn33btConvexConcaveCollisionAlgorithmD0Ev, zn33btConvexConcaveCollisionAlgorithmD1Ev };

export { zn23btConvexConvexAlgorithm10CreateFuncD1Ev, zn23btConvexConvexAlgorithm10CreateFuncD0Ev };

export { zn23btConvexConvexAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn24btPerturbedContactResultD1Ev, zn24btPerturbedContactResultD0Ev };

export { zn24btPerturbedContactResult15addContactPointERK9btVector3S2F };

export { zn23btConvexConvexAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE };

export { zn23btConvexConvexAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn23btConvexConvexAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn23btConvexConvexAlgorithmD0Ev, zn23btConvexConvexAlgorithmD1Ev };

export { zn31btConvexPlaneCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn31btConvexPlaneCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE };

export { zn31btConvexPlaneCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn31btConvexPlaneCollisionAlgorithmD0Ev, zn31btConvexPlaneCollisionAlgorithmD1Ev };

export { zn31btDefaultCollisionConfiguration25getPersistentManifoldPoolEv };

export { zn31btDefaultCollisionConfiguration25getCollisionAlgorithmPoolEv };

export { zn31btDefaultCollisionConfiguration17getStackAllocatorEv };

export { zn31btDefaultCollisionConfiguration16getSimplexSolverEv, zn31btConvexPlaneCollisionAlgorithm10CreateFuncD1Ev };

export { zn31btConvexPlaneCollisionAlgorithm10CreateFuncD0Ev };

export { zn31btConvexPlaneCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn33btConvexConcaveCollisionAlgorithm10CreateFuncD1Ev, zn33btConvexConcaveCollisionAlgorithm10CreateFuncD0Ev };

export { zn33btConvexConcaveCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncD1Ev };

export { zn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncD0Ev };

export { zn33btConvexConcaveCollisionAlgorithm17SwappedCreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn28btCompoundCollisionAlgorithm10CreateFuncD1Ev, zn28btCompoundCollisionAlgorithm10CreateFuncD0Ev };

export { zn28btCompoundCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn28btCompoundCollisionAlgorithm17SwappedCreateFuncD1Ev, zn28btCompoundCollisionAlgorithm17SwappedCreateFuncD0Ev };

export { zn28btCompoundCollisionAlgorithm17SwappedCreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn16btEmptyAlgorithm10CreateFuncD1Ev, zn16btEmptyAlgorithm10CreateFuncD0Ev };

export { zn16btEmptyAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn32btSphereSphereCollisionAlgorithm10CreateFuncD1Ev, zn32btSphereSphereCollisionAlgorithm10CreateFuncD0Ev };

export { zn32btSphereSphereCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn34btSphereTriangleCollisionAlgorithm10CreateFuncD1Ev, zn34btSphereTriangleCollisionAlgorithm10CreateFuncD0Ev };

export { zn34btSphereTriangleCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn26btBoxBoxCollisionAlgorithm10CreateFuncD1Ev, zn26btBoxBoxCollisionAlgorithm10CreateFuncD0Ev };

export { zn26btBoxBoxCollisionAlgorithm10CreateFunc24CreateCollisionAlgorithmER36btCollisionAlgorithmConstructionInfoP17btCollisionObjectS4 };

export { zn31btDefaultCollisionConfiguration31getCollisionAlgorithmCreateFuncEii, zn31btDefaultCollisionConfigurationD0Ev };

export { zn31btDefaultCollisionConfigurationD1Ev };

export { zn16btEmptyAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE };

export { zn16btEmptyAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn16btEmptyAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn16btEmptyAlgorithmD0Ev, zn16btEmptyAlgorithmD1Ev, zn16btManifoldResultD1Ev, zn16btManifoldResultD0Ev };

export { zn16btManifoldResult15addContactPointERK9btVector3S2F };

export { zn25btSimulationIslandManager26storeIslandActivationStateEP16btCollisionWorld };

export { zn20btAlignedObjectArrayIP20btPersistentManifoldE17quickSortInternalI33btPersistentManifoldSortPredicateEEvTIi };

export { zn25btSimulationIslandManager21updateActivationStateEP16btCollisionWorldP12btDispatcher };

export { zn25btSimulationIslandManagerD0Ev, zn25btSimulationIslandManagerD1Ev };

export { zn32btSphereSphereCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn32btSphereSphereCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE };

export { zn32btSphereSphereCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn32btSphereSphereCollisionAlgorithmD0Ev, zn32btSphereSphereCollisionAlgorithmD1Ev };

export { zn34btSphereTriangleCollisionAlgorithm21calculateTimeOfImpactEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn34btSphereTriangleCollisionAlgorithm22getAllContactManifoldsER20btAlignedObjectArrayIP20btPersistentManifoldE };

export { zn34btSphereTriangleCollisionAlgorithm16processCollisionEP17btCollisionObjectS1RK16btDispatcherInfoP16btManifoldResult };

export { zn34btSphereTriangleCollisionAlgorithmD0Ev, zn34btSphereTriangleCollisionAlgorithmD1Ev };

export { zn20btAlignedObjectArrayI9btElementE17quickSortInternalI31btUnionFindElementSortPredicateEEvTIi };

export { zn22SphereTriangleDetectorD1Ev, zn22SphereTriangleDetectorD0Ev };

export { znk10btBoxShape7getAabbERK11btTransformR9btVector3S4 };

export { znk10btBoxShape24localGetSupportingVertexERK9btVector3 };

export { znk10btBoxShape37localGetSupportingVertexWithoutMarginERK9btVector3 };

export { znk10btBoxShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I };

export { zn10btBoxShape9setMarginEf, znk10btBoxShape8getPlaneER9btVector3S1I, znk10btBoxShape12getNumPlanesEv };

export { znk10btBoxShape14getNumVerticesEv, znk10btBoxShape11getNumEdgesEv, znk10btBoxShape9getVertexEiR9btVector3 };

export { znk10btBoxShape8isInsideERK9btVector3f, znk10btBoxShape7getNameEv };

export { znk10btBoxShape36getNumPreferredPenetrationDirectionsEv, znk10btBoxShape21calculateLocalInertiaEfR9btVector3 };

export { znk10btBoxShape16getPlaneEquationER9btVector4i, znk10btBoxShape7getEdgeEiR9btVector3S1 };

export { znk10btBoxShape32getPreferredPenetrationDirectionEiR9btVector3, zn10btBoxShape15setLocalScalingERK9btVector3 };

export { zn10btBoxShapeD0Ev, zn10btBoxShapeD1Ev, znk14btConcaveShape9getMarginEv, zn14btConcaveShape9setMarginEf };

export { znk22btBvhTriangleMeshShape7getNameEv, znk22btBvhTriangleMeshShape28calculateSerializeBufferSizeEv };

export { zzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallbackD1Ev };

export { zzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallbackD0Ev };

export { zzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallback11processNodeEii };

export { zzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4EN21MyNodeOverlapCallbackD1Ev };

export { zzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4EN21MyNodeOverlapCallbackD0Ev };

export { zzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4EN21MyNodeOverlapCallback11processNodeEii };

export { zznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallbackD1Ev };

export { zznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallbackD0Ev };

export { zznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN21MyNodeOverlapCallback11processNodeEii };

export { znk22btBvhTriangleMeshShape18serializeSingleBvhEP12btSerializer };

export { znk22btBvhTriangleMeshShape30serializeSingleTriangleInfoMapEP12btSerializer };

export { znk19btTriangleMeshShape37localGetSupportingVertexWithoutMarginERK9btVector3 };

export { znk22btBvhTriangleMeshShape9serializeEPvP12btSerializer, zn22btBvhTriangleMeshShape15setLocalScalingERK9btVector3 };

export { znk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4 };

export { zn22btBvhTriangleMeshShapeD0Ev, zn22btBvhTriangleMeshShapeD1Ev };

export { znk21btConvexInternalShape36getNumPreferredPenetrationDirectionsEv, zn14btCapsuleShape9setMarginEf };

export { znk14btCapsuleShape7getNameEv, znk14btCapsuleShape7getAabbERK11btTransformR9btVector3S4 };

export { znk14btCapsuleShape28calculateSerializeBufferSizeEv };

export { znk14btCapsuleShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I };

export { znk14btCapsuleShape21calculateLocalInertiaEfR9btVector3 };

export { znk21btConvexInternalShape32getPreferredPenetrationDirectionEiR9btVector3 };

export { znk14btCapsuleShape9serializeEPvP12btSerializer, zn14btCapsuleShape15setLocalScalingERK9btVector3 };

export { zn14btCapsuleShapeD0Ev, zn14btCapsuleShapeD1Ev };

export { znk14btCapsuleShape37localGetSupportingVertexWithoutMarginERK9btVector3 };

export { znk16btCollisionShape28calculateSerializeBufferSizeEv };

export { znk16btCollisionShape27getContactBreakingThresholdEf, znk16btCollisionShape9serializeEPvP12btSerializer };

export { znk16btCollisionShape20serializeSingleShapeEP12btSerializer };

export { znk16btCollisionShape17getBoundingSphereER9btVector3Rf, znk16btCollisionShape20getAngularMotionDiscEv };

export { znk16btCollisionShape21calculateTemporalAabbERK11btTransformRK9btVector3S5FRS3S6, zn14btConcaveShapeD1Ev };

export { zn14btConcaveShapeD0Ev, znk17btConvexHullShape7getNameEv };

export { znk17btConvexHullShape28calculateSerializeBufferSizeEv, znk17btConvexHullShape12getNumPlanesEv };

export { znk17btConvexHullShape9getVertexEiR9btVector3, znk17btConvexHullShape7getEdgeEiR9btVector3S1 };

export { znk17btConvexHullShape11getNumEdgesEv, znk17btConvexHullShape14getNumVerticesEv };

export { znk17btConvexHullShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I };

export { znk17btConvexHullShape37localGetSupportingVertexWithoutMarginERK9btVector3 };

export { znk17btConvexHullShape8isInsideERK9btVector3f, znk17btConvexHullShape8getPlaneER9btVector3S1I };

export { zn17btConvexHullShapeD0Ev, zn17btConvexHullShapeD1Ev, zn17btConvexHullShape15setLocalScalingERK9btVector3 };

export { znk17btConvexHullShape9serializeEPvP12btSerializer };

export { znk17btConvexHullShape24localGetSupportingVertexERK9btVector3, zn17btConvexHullShape8addPointERK9btVector3 };

export { zn17btConvexHullShapeC1EPKfii, zn21btConvexInternalShape15setLocalScalingERK9btVector3 };

export { znk21btConvexInternalShape11getAabbSlowERK11btTransformR9btVector3S4 };

export { znk21btConvexInternalShape24localGetSupportingVertexERK9btVector3, zn13btConvexShapeD1Ev };

export { zn13btConvexShapeD0Ev };

export { zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN20NodeTriangleCallbackD1Ev };

export { zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN20NodeTriangleCallbackD0Ev };

export { zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN20NodeTriangleCallback28internalProcessTriangleIndexEPS2Ii };

export { zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN29QuantizedNodeTriangleCallbackD1Ev };

export { zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN29QuantizedNodeTriangleCallbackD0Ev };

export { zzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4EN29QuantizedNodeTriangleCallback28internalProcessTriangleIndexEPS2Ii };

export { znk14btOptimizedBvh16serializeInPlaceEPvjb, zn14btOptimizedBvhD0Ev, zn14btOptimizedBvhD1Ev };

export { znk23btPolyhedralConvexShape21calculateLocalInertiaEfR9btVector3 };

export { znk34btPolyhedralConvexAabbCachingShape7getAabbERK11btTransformR9btVector3S4 };

export { znk13btSphereShape37localGetSupportingVertexWithoutMarginERK9btVector3 };

export { znk13btSphereShape7getNameEv, zn13btSphereShape9setMarginEf, znk13btSphereShape9getMarginEv };

export { znk13btSphereShape49batchedUnitVectorGetSupportingVertexWithoutMarginEPK9btVector3PS0I };

export { znk13btSphereShape7getAabbERK11btTransformR9btVector3S4, znk13btSphereShape21calculateLocalInertiaEfR9btVector3 };

export { zn13btSphereShapeD0Ev, zn13btSphereShapeD1Ev, znk13btSphereShape24localGetSupportingVertexERK9btVector3 };

export { znk23btStridingMeshInterface14hasPremadeAabbEv, znk23btStridingMeshInterface14setPremadeAabbERK9btVector3S2 };

export { znk23btStridingMeshInterface14getPremadeAabbEP9btVector3S1 };

export { znk23btStridingMeshInterface28calculateSerializeBufferSizeEv };

export { znk23btStridingMeshInterface9serializeEPvP12btSerializer };

export {
  znk23btStridingMeshInterface27InternalProcessAllTrianglesEP31btInternalTriangleIndexCallbackRK9btVector3S4,
  zn22btBvhTriangleMeshShape17buildOptimizedBvhEv,
  zn22SphereTriangleDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb
};
